openAgent

1import { isAbsolute, join } from "node:path"
2import { Effect, FileSystem, PlatformError, Schema, SchemaAST, SchemaRepresentation } from "effect"
3import { HttpMethod, type HttpRouter } from "effect/unstable/http"
4import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi"
5import { format } from "prettier"
6 
7export type InputField = {
8  readonly name: string
9  readonly source: "params" | "query" | "headers" | "payload"
10}
11 
12export type Operation = {
13  readonly group: string
14  readonly name: string
15  readonly input: ReadonlyArray<InputField>
16  readonly inputMode: "none" | "optional" | "required"
17  readonly success: "value" | "void" | "stream"
18  readonly errors: ReadonlyArray<string>
19}
20 
21export type Output = {
22  readonly operations: ReadonlyArray<Operation>
23  readonly files: ReadonlyArray<{
24    readonly path: string
25    readonly content: string
26  }>
27}
28 
29export type Contract = {
30  readonly groups: ReadonlyArray<Group>
31}
32 
33export class GenerationError extends Schema.TaggedErrorClass<GenerationError>()("GenerationError", {
34  reason: Schema.String,
35}) {
36  override get message() {
37    return this.reason
38  }
39}
40 
41export type Endpoint = {
42  readonly group: string
43  readonly sourceGroup: string
44  readonly topLevel: boolean
45  readonly endpoint: HttpApiEndpoint.AnyWithProps
46  readonly params: Schema.Top | undefined
47  readonly query: Schema.Top | undefined
48  readonly headers: Schema.Top | undefined
49  readonly payloads: ReadonlyArray<Schema.Top>
50  readonly operation: Operation
51  readonly input: ReadonlyArray<InputField & { readonly optional: boolean }>
52  readonly unwrapData: boolean
53  readonly errors: ReadonlyArray<{ readonly status: number; readonly schema: Schema.Top }>
54  readonly successes: ReadonlyArray<Schema.Top>
55  readonly effectPortable: boolean
56}
57 
58export type Group = {
59  readonly identifier: string
60  readonly sourceIdentifier: string
61  readonly module: string
62  readonly endpoints: ReadonlyArray<Endpoint>
63}
64 
65type Slot = {
66  readonly name: string
67  readonly schema: Schema.Top
68}
69 
70const resolveHttpApiStatus = SchemaAST.resolveAt<number>("httpApiStatus")
71const resolveHttpApiEncoding = SchemaAST.resolveAt<HttpApiSchema.Encoding>("~httpApiEncoding")
72const resolveContentSchema = SchemaAST.resolveAt<SchemaAST.AST>("contentSchema")
73const Manifest = Schema.fromJsonString(Schema.Array(Schema.String))
74const manifestName = ".httpapi-codegen.json"
75 
76export function compile<Id extends string, Groups extends HttpApiGroup.Any>(
77  api: HttpApi.HttpApi<Id, Groups>,
78  options?: {
79    readonly groupNames?: Readonly<Record<string, string>>
80    readonly endpointNames?: Readonly<Record<string, string>>
81    readonly omitEndpoints?: ReadonlySet<string>
82  },
83): Contract {
84  const endpoints: Array<Endpoint> = []
85  const portable = new Map<SchemaAST.AST, boolean>()
86 
87  HttpApi.reflect(api, {
88    onGroup() {},
89    onEndpoint({ endpoint, errors, group, middleware }) {
90      if (options?.omitEndpoints?.has(endpoint.name)) return
91      const groupName = options?.groupNames?.[group.identifier] ?? group.identifier
92      const name = `${groupName}.${endpoint.name}`
93      const required = Array.from(middleware).find((item) => item.requiredForClient)
94      if (required !== undefined) {
95        throw new GenerationError({ reason: `Client middleware requires adapter: ${required.key}` })
96      }
97 
98      const successSchemas = Array.from(endpoint.success)
99      if (successSchemas.length === 0) successSchemas.push(HttpApiSchema.NoContent)
100      if (successSchemas.length > 1) throw new GenerationError({ reason: `Multiple success schemas: ${name}` })
101 
102      const params = normalizeTransport(endpoint.params, "params", endpoint, name)
103      const query = normalizeTransport(endpoint.query, "query", endpoint, name)
104      const headers = normalizeTransport(endpoint.headers, "headers", endpoint, name)
105      const sourcePayloads = Array.from(endpoint.payload.values()).flatMap(({ schemas }) => schemas)
106      if (sourcePayloads.length > 1) {
107        throw new GenerationError({ reason: `Multiple payload schemas: ${name}` })
108      }
109      const payloads = sourcePayloads.map((schema) => normalizeTransport(schema, "payload", endpoint, name)!)
110      const success = normalizeTransport(successSchemas[0], "success", endpoint, name)!
111      const errorSchemas = Array.from(errors).flatMap(([status, schemas]) =>
112        schemas.map((schema) => ({ status, ...normalizeTransport(schema, "error", endpoint, name)! })),
113      )
114      const inputs = [
115        ...inputFields(params?.schema, "params", name),
116        ...inputFields(query?.schema, "query", name),
117        ...inputFields(headers?.schema, "headers", name),
118        ...payloads.flatMap((item) => inputFields(item.schema, "payload", name)),
119      ]
120      const names = new Set<string>()
121      for (const field of inputs) {
122        if (names.has(field.name)) throw new GenerationError({ reason: `Input field collision: ${field.name}` })
123        names.add(field.name)
124      }
125 
126      const schemaPaths: Array<readonly [string, Schema.Top]> = [
127        ...(params === undefined ? [] : [[`${name}.params`, params.schema] as const]),
128        ...(query === undefined ? [] : [[`${name}.query`, query.schema] as const]),
129        ...(headers === undefined ? [] : [[`${name}.headers`, headers.schema] as const]),
130        ...payloads.map((item) => [`${name}.payload`, item.schema] as const),
131        ...responseSchemas(success.schema, `${name}.success`),
132        ...errorSchemas.map((item) => [`${name}.error.${item.status}`, item.schema] as const),
133      ]
134      const effectPortable =
135        [params, query, headers, ...payloads, success, ...errorSchemas].every(
136          (item) => item?.effectPortable !== false,
137        ) && streamEffectPortable(success.schema)
138      if (effectPortable) {
139        for (const [path, schema] of schemaPaths) assertPortable(schema, path, portable)
140      }
141 
142      endpoints.push({
143        group: groupName,
144        sourceGroup: group.identifier,
145        topLevel: group.topLevel,
146        endpoint,
147        params: params?.schema,
148        query: query?.schema,
149        headers: headers?.schema,
150        payloads: payloads.map((item) => item.schema),
151        input: inputs,
152        unwrapData: isDataEnvelope(success.schema),
153        successes: [success.schema],
154        errors: errorSchemas.map((item) => ({ status: item.status, schema: item.schema })),
155        effectPortable,
156        operation: {
157          group: groupName,
158          name: options?.endpointNames?.[endpoint.name] ?? clientEndpointName(endpoint.name),
159          input: inputs.map(({ name, source }) => ({ name, source })),
160          inputMode: inputs.length === 0 ? "none" : inputs.every((field) => field.optional) ? "optional" : "required",
161          success: isStreamSchema(success.schema)
162            ? "stream"
163            : HttpApiSchema.isNoContent(success.schema.ast)
164              ? "void"
165              : "value",
166          errors: [
167            ...new Set([
168              ...errorSchemas.flatMap((item) => {
169                const identifier = SchemaAST.resolveIdentifier(item.schema.ast)
170                return identifier === undefined ? [] : [identifier]
171              }),
172              "ClientError",
173            ]),
174          ],
175        },
176      })
177    },
178  })
179 
180  const modules = new Set(["client", "client-error", "index"])
181  const groups = Array.from(
182    Map.groupBy(endpoints, (endpoint) => endpoint.group),
183    ([identifier, endpoints], index) => {
184      if (new Set(endpoints.map((endpoint) => endpoint.sourceGroup)).size > 1) {
185        throw new GenerationError({ reason: `Client group name collision: ${identifier}` })
186      }
187      const base = /^[A-Za-z0-9_-]+$/.test(identifier) ? identifier : `group-${index}`
188      const module = uniqueModule(base, index, modules)
189      modules.add(module.toLowerCase())
190      return { identifier, sourceIdentifier: endpoints[0].sourceGroup, module, endpoints }
191    },
192  )
193  const publicNames = new Set<string>()
194  for (const group of groups) {
195    const endpointNames = new Set<string>()
196    for (const endpoint of group.endpoints) {
197      if (endpointNames.has(endpoint.operation.name)) {
198        throw new GenerationError({
199          reason: `Client endpoint name collision: ${group.identifier}.${endpoint.operation.name}`,
200        })
201      }
202      endpointNames.add(endpoint.operation.name)
203    }
204    const names = group.endpoints[0]?.topLevel ? group.endpoints.map((item) => item.operation.name) : [group.identifier]
205    for (const name of names) {
206      if (publicNames.has(name)) throw new GenerationError({ reason: `Client name collision: ${name}` })
207      publicNames.add(name)
208    }
209  }
210  return {
211    groups,
212  }
213}
214 
215export function emitEffect(contract: Contract): Output {
216  const endpoint = contract.groups.flatMap((group) => group.endpoints).find((endpoint) => !endpoint.effectPortable)
217  if (endpoint !== undefined) {
218    throw new GenerationError({
219      reason: `Effect schema requires authoritative import: ${endpoint.group}.${endpoint.endpoint.name}`,
220    })
221  }
222  return { operations: operations(contract.groups), files: renderEffectFiles(contract.groups) }
223}
224 
225export function emitEffectImported(
226  contract: Contract,
227  options:
228    | { readonly module: string; readonly api: string }
229    | { readonly module: string; readonly group: string }
230    | { readonly module: string; readonly endpoints: Readonly<Record<string, string>> },
231): Output {
232  return {
233    operations: operations(contract.groups),
234    files: renderImportedEffectFiles(contract.groups, options),
235  }
236}
237 
238export function emitPromise(
239  contract: Contract,
240  options?: {
241    readonly outputTypes?: Readonly<Record<string, { readonly name: string; readonly import: string }>>
242  },
243): Output {
244  const groups = contract.groups
245  for (const group of groups) {
246    for (const endpoint of group.endpoints) assertPromiseEndpoint(endpoint)
247  }
248  return {
249    operations: operations(groups),
250    files: [
251      { path: "types.ts", content: renderPromiseTypes(groups, options?.outputTypes) },
252      {
253        path: "client-error.ts",
254        content: `export type ClientErrorReason = "Transport" | "UnexpectedStatus" | "UnsupportedContentType" | "MalformedResponse"\n\nexport class ClientError extends Error {\n  override readonly name = "ClientError"\n  constructor(readonly reason: ClientErrorReason, options?: ErrorOptions) {\n    super(reason, options)\n  }\n}\n`,
255      },
256      {
257        path: "client.ts",
258        content: renderPromiseClient(groups).replace("let next: ReadableStreamReadResult<Uint8Array>", "let next"),
259      },
260      {
261        path: "index.ts",
262        content:
263          'export { ClientError, type ClientErrorReason } from "./client-error"\nexport * as OpenCode from "./client"\nexport * from "./types"\n',
264      },
265    ],
266  }
267}
268 
269function assertPromiseEndpoint(endpoint: Endpoint) {
270  const name = `${endpoint.group}.${endpoint.endpoint.name}`
271  const payload = endpoint.payloads[0]
272  const payloadEncoding = payload === undefined ? undefined : resolveHttpApiEncoding(payload.ast)
273  if (
274    payload !== undefined &&
275    (payloadEncoding?._tag ?? (HttpMethod.hasBody(endpoint.endpoint.method) ? "Json" : "FormUrlEncoded")) !== "Json"
276  ) {
277    throw new GenerationError({ reason: `Unsupported Promise payload encoding: ${name}` })
278  }
279  const success = endpoint.successes[0]
280  if (isStreamSchema(success)) {
281    if (
282      success._tag !== "StreamSse" ||
283      success.sseMode !== "data" ||
284      !SchemaAST.isNever(Schema.toType(success.error).ast)
285    ) {
286      throw new GenerationError({ reason: `Unsupported Promise stream: ${name}` })
287    }
288  } else if (
289    !HttpApiSchema.isNoContent(success.ast) &&
290    (resolveHttpApiEncoding(success.ast)?._tag ?? "Json") !== "Json"
291  ) {
292    throw new GenerationError({ reason: `Unsupported Promise success encoding: ${name}` })
293  }
294  for (const error of endpoint.errors) {
295    if (declaredErrorFields(error.schema) === undefined) {
296      throw new GenerationError({ reason: `Promise error must have a literal discriminator: ${name}` })
297    }
298    if ((resolveHttpApiEncoding(error.schema.ast)?._tag ?? "Json") !== "Json") {
299      throw new GenerationError({ reason: `Unsupported Promise error encoding: ${name}` })
300    }
301  }
302}
303 
304function operations(groups: ReadonlyArray<Group>) {
305  return groups.flatMap((group) => group.endpoints.map((endpoint) => endpoint.operation))
306}
307 
308function renderEffectFiles(groups: ReadonlyArray<Group>): Output["files"] {
309  return [
310    ...groups.map((group, index) => ({ path: `${group.module}.ts`, content: renderGroup(group, index) })),
311    {
312      path: "client-error.ts",
313      content:
314        'import { Schema } from "effect"\n\nexport class ClientError extends Schema.TaggedErrorClass<ClientError>()("ClientError", {\n  cause: Schema.Defect(),\n}) {}\n',
315    },
316    { path: "client.ts", content: renderClient(groups) },
317    {
318      path: "index.ts",
319      content: 'export { ClientError } from "./client-error"\nexport * as OpenCode from "./client"\n',
320    },
321  ]
322}
323 
324function renderImportedEffectFiles(
325  groups: ReadonlyArray<Group>,
326  options:
327    | { readonly module: string; readonly api: string }
328    | { readonly module: string; readonly group: string }
329    | { readonly module: string; readonly endpoints: Readonly<Record<string, string>> },
330): Output["files"] {
331  const adapters = groups.map((group, groupIndex) => {
332    const rawGroup = group.endpoints[0]?.topLevel ? "RawClient" : `RawClient[${JSON.stringify(group.sourceIdentifier)}]`
333    const methods = group.endpoints.map((item, endpointIndex) => {
334      const prefix = `Endpoint${groupIndex}_${endpointIndex}`
335      const request = (["params", "query", "headers", "payload"] as const)
336        .flatMap((source) => {
337          const fields = item.input.filter((field) => field.source === source)
338          if (fields.length === 0) return []
339          return [
340            `${source}: { ${fields.map((field) => `${JSON.stringify(field.name)}: input${item.operation.inputMode === "optional" ? "?." : ""}[${JSON.stringify(field.name)}]`).join(", ")} }`,
341          ]
342        })
343        .join(", ")
344      const input = item.input
345        .map(
346          (field) =>
347            `readonly ${JSON.stringify(field.name)}${field.optional ? "?" : ""}: ${prefix}Request[${JSON.stringify(field.source)}][${JSON.stringify(field.name)}]`,
348        )
349        .join("; ")
350      const argument =
351        item.operation.inputMode === "none"
352          ? ""
353          : `input${item.operation.inputMode === "optional" ? "?" : ""}: ${prefix}Input`
354      const rawCall = `raw[${JSON.stringify(item.endpoint.name)}]({ ${request} })`
355      const mapped = `${rawCall}.pipe(Effect.mapError(mapClientError)${item.unwrapData ? ", Effect.map((value) => value.data)" : ""})`
356      return `${item.operation.inputMode === "none" ? "" : `type ${prefix}Request = Parameters<${rawGroup}[${JSON.stringify(item.endpoint.name)}]>[0]\ntype ${prefix}Input = { ${input} }\n`}const ${prefix} = (raw: ${rawGroup}) => (${argument}) => ${item.operation.success === "stream" ? `Stream.unwrap(${rawCall}.pipe(Effect.mapError(mapClientError), Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError)))))` : mapped}`
357    })
358    return `${methods.join("\n\n")}\n\nconst adaptGroup${groupIndex} = (raw: ${rawGroup}) => ({ ${group.endpoints.map((item, endpointIndex) => `${JSON.stringify(item.operation.name)}: Endpoint${groupIndex}_${endpointIndex}(raw)`).join(", ")} })`
359  })
360  const fields = groups.flatMap((group, index) =>
361    group.endpoints[0]?.topLevel
362      ? [`...adaptGroup${index}(raw)`]
363      : [`${JSON.stringify(group.identifier)}: adaptGroup${index}(raw[${JSON.stringify(group.sourceIdentifier)}])`],
364  )
365  const usesStream = groups.some((group) => group.endpoints.some((item) => item.operation.success === "stream"))
366  const imported = "api" in options
367  const projection = imported
368    ? undefined
369    : "group" in options
370      ? renderImportedGroup(options.group)
371      : renderImportedProjection(groups, options.endpoints)
372  const api = imported ? options.api : "Api"
373  const imports =
374    projection === undefined
375      ? `import { ${api} } from ${JSON.stringify(options.module)}`
376      : `import { HttpApi, HttpApiClient${"endpoints" in options ? ", HttpApiGroup" : ""} } from "effect/unstable/httpapi"\nimport { ${projection.imports.join(", ")} } from ${JSON.stringify(options.module)}`
377  const httpApiImport = projection === undefined ? 'import { HttpApiClient } from "effect/unstable/httpapi"\n' : ""
378  const client = `// Generated by @opencode-ai/httpapi-codegen. Do not edit.\nimport { Effect${usesStream ? ", Stream" : ""}, Schema } from "effect"\nimport { Sse } from "effect/unstable/encoding"\nimport { HttpClientError } from "effect/unstable/http"\n${httpApiImport}${imports}\nimport { ClientError } from "./client-error"\n\n${projection?.source ?? ""}type RawClient = HttpApiClient.ForApi<typeof ${api}>\n\nconst mapClientError = <E>(error: E) => HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error) ? new ClientError({ cause: error }) : error\n\n${adapters.join("\n\n")}\n\nconst adaptClient = (raw: RawClient) => ({ ${fields.join(", ")} })\n\nexport const make = (options?: { readonly baseUrl?: URL | string }) => HttpApiClient.make(${api}, options).pipe(Effect.map(adaptClient))\n`
379  return [
380    {
381      path: "client-error.ts",
382      content:
383        'import { Schema } from "effect"\n\nexport class ClientError extends Schema.TaggedErrorClass<ClientError>()("ClientError", {\n  cause: Schema.Defect(),\n}) {}\n',
384    },
385    { path: "client.ts", content: client },
386    {
387      path: "index.ts",
388      content: 'export { ClientError } from "./client-error"\nexport * as OpenCode from "./client"\n',
389    },
390  ]
391}
392 
393function renderImportedGroup(group: string) {
394  return {
395    imports: [group],
396    source: `const Api = HttpApi.make("generated").add(${group})\n\n`,
397  }
398}
399 
400function renderImportedProjection(groups: ReadonlyArray<Group>, endpoints: Readonly<Record<string, string>>) {
401  const imports = groups.flatMap((group) =>
402    group.endpoints.map((endpoint) => {
403      const name = endpoints[`${group.identifier}.${endpoint.endpoint.name}`]
404      if (name === undefined) {
405        throw new GenerationError({
406          reason: `Missing imported endpoint: ${group.identifier}.${endpoint.endpoint.name}`,
407        })
408      }
409      return name
410    }),
411  )
412  const source = `const Api = HttpApi.make("generated").${groups
413    .map((group) => {
414      const options = group.endpoints[0]?.topLevel ? ", { topLevel: true }" : ""
415      return `add(HttpApiGroup.make(${JSON.stringify(group.identifier)}${options})${group.endpoints.map((endpoint) => `.add(${endpoints[`${group.identifier}.${endpoint.endpoint.name}`]})`).join("")})`
416    })
417    .join(".")}\n\n`
418  return { imports: [...new Set(imports)], source }
419}
420 
421function renderPromiseTypes(
422  groups: ReadonlyArray<Group>,
423  outputTypes?: Readonly<Record<string, { readonly name: string; readonly import: string }>>,
424) {
425  const types = new Map<SchemaAST.AST, string>()
426  const typeOf = (schema: Schema.Top, decoded = false) => {
427    const projected = decoded ? Schema.toType(schema) : Schema.toEncoded(schema)
428    const cached = types.get(projected.ast)
429    if (cached !== undefined) return cached
430    const type = structuralType(projected)
431    types.set(projected.ast, type)
432    return type
433  }
434  const errors = new Map(
435    groups.flatMap((group) =>
436      group.endpoints.flatMap((endpoint) =>
437        endpoint.errors.flatMap((error) => {
438          const tagged = declaredErrorFields(error.schema)
439          return tagged === undefined ? [] : [[tagged.tag, tagged] as const]
440        }),
441      ),
442    ),
443  )
444  const errorTypes = Array.from(errors.values()).map((error) => {
445    const fields = error.fields
446      .map(([name, schema, optional]) => `readonly ${JSON.stringify(name)}${optional ? "?" : ""}: ${typeOf(schema)}`)
447      .join("; ")
448    return `export type ${error.identifier} = { readonly ${JSON.stringify(error.key)}: ${JSON.stringify(error.tag)}; ${fields} }\nexport const is${error.identifier} = (value: unknown): value is ${error.identifier} => typeof value === "object" && value !== null && ${JSON.stringify(error.key)} in value && value[${JSON.stringify(error.key)}] === ${JSON.stringify(error.tag)}`
449  })
450  const operations = groups
451    .flatMap((group) =>
452      group.endpoints.flatMap((endpoint) => {
453        const prefix = promiseTypePrefix(group.identifier, endpoint.operation.name)
454        const schemas = {
455          params: endpoint.params,
456          query: endpoint.query,
457          headers: endpoint.headers,
458          payload: endpoint.payloads[0],
459        }
460        const input = endpoint.input
461          .map((field) => {
462            const schema = schemas[field.source]
463            if (schema === undefined)
464              throw new GenerationError({ reason: `Missing input schema: ${prefix}.${field.name}` })
465            return `readonly ${JSON.stringify(field.name)}${field.optional ? "?" : ""}: (${typeOf(schema, field.source === "query")})[${JSON.stringify(field.name)}]`
466          })
467          .join("; ")
468        const successSchema = endpoint.successes[0]
469        const success =
470          outputTypes?.[`${group.identifier}.${endpoint.operation.name}`]?.name ??
471          typeOf(
472            isStreamSchema(successSchema) && successSchema._tag === "StreamSse"
473              ? successSchema.sseMode === "data"
474                ? streamEncodedDataSchema(successSchema)
475                : successSchema.events
476              : successSchema,
477          )
478        return [
479          ...(endpoint.operation.inputMode === "none" ? [] : [`export type ${prefix}Input = { ${input} }`]),
480          `export type ${prefix}Output = ${endpoint.unwrapData ? `(${success})["data"]` : success}`,
481        ]
482      }),
483    )
484    .join("\n\n")
485  const json = operations.includes("JsonValue")
486    ? "export type JsonValue = null | boolean | number | string | ReadonlyArray<JsonValue> | { readonly [key: string]: JsonValue }"
487    : ""
488  const imports = [...new Set(Object.values(outputTypes ?? {}).map((override) => override.import))]
489  return [...imports, json, ...errorTypes, operations].filter(Boolean).join("\n\n")
490}
491 
492function renderPromiseClient(groups: ReadonlyArray<Group>) {
493  const imports = groups.flatMap((group) =>
494    group.endpoints.flatMap((endpoint) => {
495      const prefix = promiseTypePrefix(group.identifier, endpoint.operation.name)
496      return [...(endpoint.operation.inputMode === "none" ? [] : [`${prefix}Input`]), `${prefix}Output`]
497    }),
498  )
499  const fields = groups.map((group) => {
500    const methods = group.endpoints.map((endpoint) => {
501      const prefix = promiseTypePrefix(group.identifier, endpoint.operation.name)
502      const argument =
503        endpoint.operation.inputMode === "none"
504          ? "requestOptions?: RequestOptions"
505          : `input${endpoint.operation.inputMode === "optional" ? "?" : ""}: ${prefix}Input, requestOptions?: RequestOptions`
506      const path = promisePath(endpoint.endpoint.path, endpoint.input)
507      const access = (name: string) =>
508        `input${endpoint.operation.inputMode === "optional" ? "?." : ""}[${JSON.stringify(name)}]`
509      const part = (source: InputField["source"]) => {
510        const inputs = endpoint.input.filter((field) => field.source === source)
511        return inputs.length === 0
512          ? undefined
513          : `{ ${inputs.map((field) => `${JSON.stringify(field.name)}: ${access(field.name)}`).join(", ")} }`
514      }
515      const parts = [
516        endpoint.query === undefined ? undefined : `query: ${part("query")}`,
517        endpoint.headers === undefined ? undefined : `headers: ${part("headers")}`,
518        endpoint.payloads.length === 0 ? undefined : `body: ${part("payload")}`,
519      ].filter((value): value is string => value !== undefined)
520      const declaredStatuses = [...new Set(endpoint.errors.map((error) => error.status))]
521      const descriptor = `{ method: ${JSON.stringify(endpoint.endpoint.method)}, path: ${path}${parts.length === 0 ? "" : `, ${parts.join(", ")}`}, successStatus: ${resolveHttpApiStatus(endpoint.successes[0].ast) ?? 200}, declaredStatuses: [${declaredStatuses.join(", ")}], empty: ${endpoint.operation.success === "void"} }`
522      if (endpoint.operation.success === "stream") {
523        const success = endpoint.successes[0]
524        if (!isStreamSchema(success) || success._tag !== "StreamSse" || success.sseMode !== "data") {
525          throw new GenerationError({
526            reason: `Promise stream emission is not implemented: ${group.identifier}.${endpoint.endpoint.name}`,
527          })
528        }
529        return `${JSON.stringify(endpoint.operation.name)}: (${argument}): AsyncIterable<${prefix}Output> => sse<${prefix}Output>(${descriptor}, requestOptions)`
530      }
531      const unwrap = endpoint.unwrapData ? ".then((value) => value.data)" : ""
532      return `${JSON.stringify(endpoint.operation.name)}: (${argument}) => request<${endpoint.unwrapData ? `{ readonly data: ${prefix}Output }` : `${prefix}Output`}>(${descriptor}, requestOptions)${unwrap}`
533    })
534    if (group.endpoints[0]?.topLevel) return methods.join(", ")
535    return `${JSON.stringify(group.identifier)}: { ${methods.join(", ")} }`
536  })
537  return `import type { ${imports.join(", ")} } from "./types"\nimport { ClientError } from "./client-error"\n\nexport interface ClientOptions {\n  readonly baseUrl: string\n  readonly fetch?: typeof globalThis.fetch\n  readonly headers?: HeadersInit\n}\n\nexport interface RequestOptions {\n  readonly signal?: AbortSignal\n  readonly headers?: HeadersInit\n}\n\ninterface RequestDescriptor {\n  readonly method: string\n  readonly path: string\n  readonly query?: Record<string, unknown>\n  readonly headers?: Record<string, unknown>\n  readonly body?: unknown\n  readonly successStatus: number\n  readonly declaredStatuses: ReadonlyArray<number>\n  readonly empty: boolean\n}\n\nexport function make(options: ClientOptions) {\n  const fetch = options.fetch ?? globalThis.fetch\n\n  const prepare = (descriptor: RequestDescriptor, requestOptions?: RequestOptions) => {\n    const url = new URL(descriptor.path, options.baseUrl)\n    for (const [key, value] of Object.entries(descriptor.query ?? {})) appendQuery(url.searchParams, key, value)\n    const headers = new Headers(options.headers)\n    for (const [key, value] of Object.entries(descriptor.headers ?? {})) {\n      if (value !== undefined && value !== null) headers.set(key, String(value))\n    }\n    for (const [key, value] of new Headers(requestOptions?.headers)) headers.set(key, value)\n    if (descriptor.body !== undefined && !headers.has("content-type")) headers.set("content-type", "application/json")\n    return {\n      url,\n      init: {\n        method: descriptor.method,\n        signal: requestOptions?.signal,\n        headers,\n        body: descriptor.body === undefined ? undefined : JSON.stringify(descriptor.body),\n      } satisfies RequestInit,\n    }\n  }\n\n  const execute = async (descriptor: RequestDescriptor, requestOptions?: RequestOptions) => {\n    try {\n      const prepared = prepare(descriptor, requestOptions)\n      return await fetch(prepared.url, prepared.init)\n    } catch (cause) {\n      throw new ClientError("Transport", { cause })\n    }\n  }\n\n  const responseError = async (response: Response, descriptor: RequestDescriptor): Promise<never> => {\n    if (descriptor.declaredStatuses.includes(response.status)) throw await json(response)\n    try {\n      await response.body?.cancel()\n    } catch {}\n    throw new ClientError("UnexpectedStatus", { cause: { status: response.status } })\n  }\n\n  const request = async <A>(descriptor: RequestDescriptor, requestOptions?: RequestOptions): Promise<A> => {\n    const response = await execute(descriptor, requestOptions)\n    if (response.status !== descriptor.successStatus) return responseError(response, descriptor)\n    if (descriptor.empty) {\n      try {\n        await response.body?.cancel()\n      } catch {}\n      return undefined as A\n    }\n    return await json(response) as A\n  }\n\n  const sse = <A>(descriptor: RequestDescriptor, requestOptions?: RequestOptions): AsyncIterable<A> => ({\n    async *[Symbol.asyncIterator]() {\n      const response = await execute(descriptor, requestOptions)\n      if (response.status !== descriptor.successStatus) await responseError(response, descriptor)\n      if (!isContentType(response, "text/event-stream")) {\n        try {\n          await response.body?.cancel()\n        } catch {}\n        throw new ClientError("UnsupportedContentType")\n      }\n      if (response.body === null) throw new ClientError("MalformedResponse")\n      const reader = response.body.getReader()\n      const decoder = new TextDecoder()\n      let buffer = ""\n      try {\n        while (true) {\n          let next: ReadableStreamReadResult<Uint8Array>\n          try {\n            next = await reader.read()\n          } catch (cause) {\n            throw new ClientError("Transport", { cause })\n          }\n          buffer += decoder.decode(next.value, { stream: !next.done })\n          if (buffer.length > 1_048_576) throw new ClientError("MalformedResponse")\n          const trailingCarriageReturn = !next.done && buffer.endsWith("\\r")\n          if (trailingCarriageReturn) buffer = buffer.slice(0, -1)\n          buffer = buffer.replaceAll("\\r\\n", "\\n").replaceAll("\\r", "\\n")\n          if (trailingCarriageReturn) buffer += "\\r"\n          if (next.done && buffer !== "") buffer += "\\n\\n"\n          let boundary = buffer.indexOf("\\n\\n")\n          while (boundary >= 0) {\n            const block = buffer.slice(0, boundary)\n            buffer = buffer.slice(boundary + 2)\n            const data = block.split("\\n").flatMap((line) => line.startsWith("data:") ? [line.slice(5).trimStart()] : []).join("\\n")\n            if (data !== "") {\n              try {\n                yield JSON.parse(data) as A\n              } catch (cause) {\n                throw new ClientError("MalformedResponse", { cause })\n              }\n            }\n            boundary = buffer.indexOf("\\n\\n")\n          }\n          if (next.done) return\n        }\n      } finally {\n        try {\n          await reader.cancel()\n        } catch {}\n        reader.releaseLock()\n      }\n    },\n  })\n\n  return { ${fields.join(", ")} }\n}\n\nfunction appendQuery(params: URLSearchParams, key: string, value: unknown): void {\n  if (value === undefined || value === null) return\n  if (Array.isArray(value)) {\n    for (const item of value) appendQuery(params, key, item)\n    return\n  }\n  if (typeof value === "object") {\n    for (const [child, item] of Object.entries(value)) appendQuery(params, \`\${key}[\${child}]\`, item)\n    return\n  }\n  params.append(key, String(value))\n}\n\nasync function json(response: Response): Promise<unknown> {\n  if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {\n    try {\n      await response.body?.cancel()\n    } catch {}\n    throw new ClientError("UnsupportedContentType")\n  }\n  let text: string\n  try {\n    text = await response.text()\n  } catch (cause) {\n    throw new ClientError("Transport", { cause })\n  }\n  if (text === "") throw new ClientError("MalformedResponse")\n  try {\n    return JSON.parse(text)\n  } catch (cause) {\n    throw new ClientError("MalformedResponse", { cause })\n  }\n}\n\nfunction isContentType(response: Response, expected: string) {\n  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected\n}\n`
538}
539 
540function promiseTypePrefix(group: string, endpoint: string) {
541  return `${identifierPart(group)}${identifierPart(endpoint)}`
542}
543 
544function clientEndpointName(name: string) {
545  return name.slice(name.lastIndexOf(".") + 1)
546}
547 
548function identifierPart(value: string) {
549  return value
550    .split(/[^A-Za-z0-9]+/)
551    .filter(Boolean)
552    .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
553    .join("")
554}
555 
556function structuralType(schema: Schema.Top) {
557  const document = SchemaRepresentation.toCodeDocument(SchemaRepresentation.fromASTs([schema.ast]))
558  if (
559    document.artifacts.some(
560      (artifact) =>
561        artifact._tag !== "Import" || artifact.importDeclaration !== 'import type * as Brand from "effect/Brand"',
562    ) ||
563    Object.keys(document.references.recursives).length > 0
564  ) {
565    throw new GenerationError({ reason: "Referenced Promise types are not implemented" })
566  }
567  const references = new Map(
568    document.references.nonRecursives.map((reference) => [reference.$ref, reference.code.Type]),
569  )
570  const expand = (type: string, seen = new Set<string>()): string => {
571    for (const [reference, value] of references) {
572      const pattern = `(?<![A-Za-z0-9_$.'"])${reference.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![A-Za-z0-9_$.'"])`
573      if (!new RegExp(pattern).test(type)) continue
574      if (seen.has(reference)) {
575        throw new GenerationError({ reason: `Recursive Promise types are not implemented: ${reference}` })
576      }
577      type = type.replace(new RegExp(pattern, "g"), `(${expand(value, new Set([...seen, reference]))})`)
578    }
579    return type
580  }
581  return expand(document.codes[0].Type)
582    .replaceAll(/ & Brand\.Brand<"[^"]+">/g, "")
583    .replaceAll("Schema.Json", "JsonValue")
584}
585 
586function promisePath(path: string, input: ReadonlyArray<InputField>) {
587  if (path.includes("*")) throw new GenerationError({ reason: `Unsupported Promise path wildcard: ${path}` })
588  const fields = new Set(input.filter((field) => field.source === "params").map((field) => field.name))
589  const segments = path.split(/(:[A-Za-z_][A-Za-z0-9_]*)/g).filter(Boolean)
590  const template = segments
591    .map((segment) => {
592      if (!segment.startsWith(":")) return segment.replaceAll("`", "\\`")
593      const name = segment.slice(1)
594      if (!fields.has(name)) throw new GenerationError({ reason: `Missing path parameter: ${name}` })
595      return `\${encodeURIComponent(input.${name})}`
596    })
597    .join("")
598  return `\`${template}\``
599}
600 
601function uniqueModule(base: string, index: number, modules: ReadonlySet<string>) {
602  if (!modules.has(base.toLowerCase())) return base
603  const seed = `${base}-${index}`
604  let suffix = 0
605  while (modules.has(`${seed}${suffix === 0 ? "" : `-${suffix}`}`.toLowerCase())) suffix++
606  return `${seed}${suffix === 0 ? "" : `-${suffix}`}`
607}
608 
609function normalizeTransport(
610  schema: Schema.Top | undefined,
611  source: InputField["source"] | "success" | "error",
612  endpoint: HttpApiEndpoint.AnyWithProps,
613  operation: string,
614) {
615  if (schema === undefined) return undefined
616  if (isStreamSchema(schema)) return { schema, effectPortable: true } as const
617  if (!metadataPortable(schema.ast, new Set())) {
618    throw new GenerationError({ reason: `Unportable schema: ${operation}.${source}` })
619  }
620  const decoded = Schema.toType(schema)
621  if (!isPathInput(endpoint.path)) {
622    throw new GenerationError({ reason: `Invalid endpoint path: ${operation}` })
623  }
624  const rebuilt = HttpApiEndpoint.make(endpoint.method)(endpoint.name, endpoint.path, {
625    ...(source === "params" ? { params: decoded } : undefined),
626    ...(source === "query" ? { query: decoded } : undefined),
627    ...(source === "headers" ? { headers: decoded } : undefined),
628    ...(source === "payload" ? { payload: decoded } : undefined),
629    ...(source === "success" ? { success: decoded } : { success: Schema.String }),
630    ...(source === "error" ? { error: decoded } : undefined),
631  })
632  const normalized =
633    source === "params"
634      ? rebuilt.params
635      : source === "query"
636        ? rebuilt.query
637        : source === "headers"
638          ? rebuilt.headers
639          : source === "payload"
640            ? Array.from(rebuilt.payload.values())[0]?.schemas[0]
641            : source === "success"
642              ? Array.from(rebuilt.success)[0]
643              : Array.from(rebuilt.error)[0]
644  if (normalized === undefined) throw new GenerationError({ reason: `Unportable schema: ${operation}.${source}` })
645  if (!sameEncoding(schema.ast, normalized.ast)) return { schema, effectPortable: false } as const
646  return { schema: decoded, effectPortable: true } as const
647}
648 
649function isPathInput(path: string): path is HttpRouter.PathInput {
650  return path === "*" || path.startsWith("/")
651}
652 
653function sameEncoding(left: SchemaAST.AST, right: SchemaAST.AST): boolean {
654  if (left._tag !== right._tag || left.encoding?.length !== right.encoding?.length) return false
655  if (
656    left.encoding?.some((link, index) => {
657      const other = right.encoding?.[index]
658      return other === undefined || link.transformation !== other.transformation || !sameEncoding(link.to, other.to)
659    })
660  )
661    return false
662  if (!sameChecks(left.checks, right.checks) || !sameContext(left.context, right.context)) return false
663  if (SchemaAST.isSuspend(left) && SchemaAST.isSuspend(right)) return sameEncoding(left.thunk(), right.thunk())
664  if (SchemaAST.isUnion(left) && SchemaAST.isUnion(right)) {
665    return (
666      left.types.length === right.types.length &&
667      left.types.every((ast, index) => sameEncoding(ast, right.types[index]))
668    )
669  }
670  if (SchemaAST.isArrays(left) && SchemaAST.isArrays(right)) {
671    return (
672      left.elements.length === right.elements.length &&
673      left.rest.length === right.rest.length &&
674      left.elements.every((ast, index) => sameEncoding(ast, right.elements[index])) &&
675      left.rest.every((ast, index) => sameEncoding(ast, right.rest[index]))
676    )
677  }
678  if (SchemaAST.isObjects(left) && SchemaAST.isObjects(right)) {
679    return (
680      left.propertySignatures.length === right.propertySignatures.length &&
681      left.indexSignatures.length === right.indexSignatures.length &&
682      left.propertySignatures.every((field, index) => sameEncoding(field.type, right.propertySignatures[index].type)) &&
683      left.indexSignatures.every(
684        (field, index) =>
685          sameEncoding(field.parameter, right.indexSignatures[index].parameter) &&
686          sameEncoding(field.type, right.indexSignatures[index].type),
687      )
688    )
689  }
690  return true
691}
692 
693function sameChecks(left: SchemaAST.Checks | undefined, right: SchemaAST.Checks | undefined): boolean {
694  if (left?.length !== right?.length) return false
695  if (left === undefined || right === undefined) return true
696  return left.every((check, index) => {
697    const other = right[index]
698    if (other === undefined || check._tag !== other._tag) return false
699    if (check._tag === "Filter" && other._tag === "Filter") {
700      return check.run === other.run && check.aborted === other.aborted
701    }
702    return check._tag === "FilterGroup" && other._tag === "FilterGroup" && sameChecks(check.checks, other.checks)
703  })
704}
705 
706function sameContext(left: SchemaAST.Context | undefined, right: SchemaAST.Context | undefined) {
707  return left?.isOptional === right?.isOptional && left?.isMutable === right?.isMutable
708}
709 
710export function write(
711  output: Output,
712  directory: string,
713): Effect.Effect<void, GenerationError | PlatformError.PlatformError, FileSystem.FileSystem> {
714  return Effect.gen(function* () {
715    const paths = new Set<string>()
716    const normalizedPaths = new Set<string>()
717    for (const file of output.files) {
718      if (!isSafeOutputPath(file.path)) yield* new GenerationError({ reason: `Unsafe output path: ${file.path}` })
719      const path = file.path.toLowerCase()
720      if (normalizedPaths.has(path)) yield* new GenerationError({ reason: `Duplicate output path: ${file.path}` })
721      normalizedPaths.add(path)
722      paths.add(file.path)
723    }
724    const fs = yield* FileSystem.FileSystem
725    yield* fs.makeDirectory(directory, { recursive: true })
726    const manifest = join(directory, manifestName)
727    const previous = (yield* fs.exists(manifest))
728      ? yield* fs.readFileString(manifest).pipe(
729          Effect.flatMap(Schema.decodeUnknownEffect(Manifest)),
730          Effect.mapError(() => new GenerationError({ reason: `Invalid generated file manifest: ${manifest}` })),
731        )
732      : []
733    if (previous.some((path) => !isSafeOutputPath(path))) {
734      yield* new GenerationError({ reason: `Invalid generated file manifest: ${manifest}` })
735    }
736    yield* Effect.forEach(
737      previous.filter((path) => !paths.has(path)),
738      (path) => fs.remove(join(directory, path), { force: true }),
739      { concurrency: 8, discard: true },
740    )
741    yield* Effect.forEach(
742      output.files,
743      (file) =>
744        fs.exists(join(directory, file.path)).pipe(
745          Effect.flatMap((exists) => (exists ? fs.stat(join(directory, file.path)) : Effect.succeed(undefined))),
746          Effect.flatMap((info) =>
747            info?.type === "SymbolicLink"
748              ? new GenerationError({ reason: `Unsafe output path: ${file.path}` })
749              : Effect.void,
750          ),
751        ),
752      { concurrency: 8, discard: true },
753    )
754    yield* Effect.forEach(
755      output.files,
756      (file) =>
757        Effect.tryPromise({
758          try: () => format(file.content, { filepath: file.path, parser: "typescript", semi: false, printWidth: 120 }),
759          catch: (error) => new GenerationError({ reason: `Failed to format ${file.path}: ${String(error)}` }),
760        }).pipe(Effect.flatMap((content) => fs.writeFileString(join(directory, file.path), content))),
761      { concurrency: 8, discard: true },
762    )
763    yield* fs.writeFileString(manifest, JSON.stringify(output.files.map((file) => file.path).sort(), null, 2) + "\n")
764  })
765}
766 
767function isSafeOutputPath(path: string) {
768  return path !== manifestName && !isAbsolute(path) && path !== "." && path !== ".." && !/[\\/]/.test(path)
769}
770 
771export function generate<Id extends string, Groups extends HttpApiGroup.Any>(
772  api: HttpApi.HttpApi<Id, Groups>,
773  options: { readonly directory: string },
774): Effect.Effect<void, GenerationError | PlatformError.PlatformError, FileSystem.FileSystem> {
775  return Effect.try({
776    try: () => emitEffect(compile(api)),
777    catch: (error) => (error instanceof GenerationError ? error : new GenerationError({ reason: String(error) })),
778  }).pipe(Effect.flatMap((output) => write(output, options.directory)))
779}
780 
781function inputFields(schema: Schema.Top | undefined, source: InputField["source"], operation: string) {
782  if (schema === undefined) return []
783  const ast = Schema.toType(schema).ast
784  if (!SchemaAST.isObjects(ast) || ast.indexSignatures.length > 0) {
785    throw new GenerationError({ reason: `Input schema must be a struct: ${operation}.${source}` })
786  }
787  return ast.propertySignatures.map((field) => {
788    if (typeof field.name !== "string") {
789      throw new GenerationError({ reason: `Input field must have a string name: ${operation}.${source}` })
790    }
791    return {
792      name: field.name,
793      source,
794      optional: SchemaAST.isOptional(field.type),
795    }
796  })
797}
798 
799function responseSchemas(schema: Schema.Top, path: string): Array<readonly [string, Schema.Top]> {
800  if (HttpApiSchema.isNoContent(schema.ast)) return []
801  if (!isStreamSchema(schema)) return [[path, schema]]
802  if (schema._tag === "StreamUint8Array") return []
803  const value = schema.sseMode === "data" ? streamDataSchema(schema) : schema.events
804  return [
805    [`${path}.${schema.sseMode}`, value],
806    [`${path}.error`, schema.error],
807  ]
808}
809 
810function assertPortable(schema: Schema.Top, path: string, portable: Map<SchemaAST.AST, boolean>) {
811  const visiting = new Set<SchemaAST.AST>()
812  const taggedError = taggedErrorFields(schema)
813  const visit = (ast: SchemaAST.AST): boolean => {
814    const cached = portable.get(ast)
815    if (cached !== undefined) return cached
816    if (visiting.has(ast)) return true
817    visiting.add(ast)
818    const result = visitCurrent(ast)
819    visiting.delete(ast)
820    portable.set(ast, result)
821    return result
822  }
823  const visitCurrent = (ast: SchemaAST.AST): boolean => {
824    if (!annotationsPortable(ast.annotations)) return false
825    if (!checksPortable(ast.checks) || ("encodingChecks" in ast && !checksPortable(ast.encodingChecks))) return false
826    if (SchemaAST.isDeclaration(ast)) {
827      return generationPortable(ast.annotations?.generation) && ast.typeParameters.every(visit)
828    }
829    if (ast.encoding !== undefined && ast.annotations?.generation === undefined) return false
830    if (SchemaAST.isSuspend(ast)) return visit(ast.thunk())
831    if (SchemaAST.isUnion(ast)) return ast.types.every(visit)
832    if (SchemaAST.isArrays(ast)) {
833      return ast.elements.every(visit) && ast.rest.every(visit)
834    }
835    if (SchemaAST.isObjects(ast)) {
836      return (
837        ast.propertySignatures.every((field) => visit(field.type)) &&
838        ast.indexSignatures.every((index) => visit(index.parameter) && visit(index.type))
839      )
840    }
841    if (SchemaAST.isTemplateLiteral(ast)) return ast.parts.every(visit)
842    return true
843  }
844  if (taggedError !== undefined && SchemaAST.isDeclaration(schema.ast)) {
845    if (
846      schema.ast.checks !== undefined ||
847      ("encodingChecks" in schema.ast && !checksPortable(schema.ast.encodingChecks)) ||
848      schema.ast.typeParameters.some((ast) => ast.checks !== undefined) ||
849      !schema.ast.typeParameters.every(visit)
850    ) {
851      throw new GenerationError({ reason: `Unportable schema: ${path}` })
852    }
853    return
854  }
855  if (!visit(schema.ast)) throw new GenerationError({ reason: `Unportable schema: ${path}` })
856}
857 
858function checksPortable(checks: SchemaAST.Checks | undefined): boolean {
859  if (checks === undefined) return true
860  return checks.every((check) =>
861    check._tag === "Filter"
862      ? !check.aborted &&
863        check.annotations?.meta !== undefined &&
864        typeof check.annotations.arbitrary === "object" &&
865        check.annotations.arbitrary !== null &&
866        "constraint" in check.annotations.arbitrary
867      : checksPortable(check.checks),
868  )
869}
870 
871function metadataPortable(ast: SchemaAST.AST, seen: Set<SchemaAST.AST>): boolean {
872  if (seen.has(ast)) return true
873  seen.add(ast)
874  if (!annotationsPortable(ast.annotations) || !checksPortable(ast.checks)) return false
875  if ("encodingChecks" in ast && !checksPortable(ast.encodingChecks)) return false
876  if (ast.encoding?.some((link) => !metadataPortable(link.to, seen))) return false
877  if (SchemaAST.isDeclaration(ast)) return ast.typeParameters.every((item) => metadataPortable(item, seen))
878  if (SchemaAST.isSuspend(ast)) return metadataPortable(ast.thunk(), seen)
879  if (SchemaAST.isUnion(ast)) return ast.types.every((item) => metadataPortable(item, seen))
880  if (SchemaAST.isArrays(ast)) {
881    return (
882      ast.elements.every((item) => metadataPortable(item, seen)) &&
883      ast.rest.every((item) => metadataPortable(item, seen))
884    )
885  }
886  if (SchemaAST.isObjects(ast)) {
887    return (
888      ast.propertySignatures.every((field) => metadataPortable(field.type, seen)) &&
889      ast.indexSignatures.every(
890        (field) => metadataPortable(field.parameter, seen) && metadataPortable(field.type, seen),
891      )
892    )
893  }
894  return true
895}
896 
897function generationPortable(generation: unknown): boolean {
898  if (typeof generation !== "object" || generation === null) return false
899  const value = generation as {
900    readonly runtime?: unknown
901    readonly Type?: unknown
902    readonly importDeclaration?: unknown
903  }
904  if (typeof value.runtime !== "string" || typeof value.Type !== "string") return false
905  if (value.importDeclaration !== undefined) {
906    if (
907      typeof value.importDeclaration !== "string" ||
908      !/from ["']effect(?:\/[^"']+)?["']$/.test(value.importDeclaration)
909    ) {
910      return false
911    }
912  }
913  const namespace =
914    typeof value.importDeclaration === "string"
915      ? /import(?: type)? \* as ([A-Za-z_$][\w$]*)/.exec(value.importDeclaration)?.[1]
916      : undefined
917  return value.runtime.startsWith("Schema.") || (namespace !== undefined && value.runtime.startsWith(`${namespace}.`))
918}
919 
920function annotationsPortable(annotations: Schema.Annotations.Annotations | undefined) {
921  if (annotations === undefined) return true
922  return Object.entries(annotations).every(([key, value]) => {
923    if (
924      ["toCodec", "toCodecJson", "toArbitrary", "toFormatter", "toEquivalence", "~effect/Schema/Class"].includes(key)
925    ) {
926      return true
927    }
928    if (key === "generation") return generationPortable(value)
929    return serializable(value)
930  })
931}
932 
933function serializable(value: unknown): boolean {
934  if (value === null || ["string", "number", "boolean"].includes(typeof value)) return true
935  if (Array.isArray(value)) return value.every(serializable)
936  if (typeof value !== "object") return false
937  return Object.values(value).every(serializable)
938}
939 
940function taggedErrorFields(schema: Schema.Top) {
941  const fields = declaredErrorFields(schema)
942  return fields?.key === "_tag" ? fields : undefined
943}
944 
945function declaredErrorFields(schema: Schema.Top) {
946  if (!SchemaAST.isDeclaration(schema.ast) || schema.ast.annotations?.["~effect/Schema/Class"] === undefined) {
947    return undefined
948  }
949  const fields = schema.ast.typeParameters[0]
950  if (!SchemaAST.isObjects(fields) || fields.indexSignatures.length > 0) return undefined
951  const key = fields.propertySignatures.find((field) => field.name === "_tag" || field.name === "name")?.name
952  if (key !== "_tag" && key !== "name") return undefined
953  const tag = fields.propertySignatures.find((field) => field.name === key)?.type
954  if (tag === undefined || !SchemaAST.isLiteral(tag) || typeof tag.literal !== "string") return undefined
955  return {
956    key,
957    tag: tag.literal,
958    identifier: SchemaAST.resolveIdentifier(schema.ast) ?? tag.literal,
959    fields: fields.propertySignatures.flatMap((field) =>
960      field.name === key || typeof field.name !== "string"
961        ? []
962        : [[field.name, Schema.make(field.type), SchemaAST.isOptional(field.type)] as const],
963    ),
964  }
965}
966 
967function isDataEnvelope(schema: Schema.Top) {
968  if (isStreamSchema(schema) || HttpApiSchema.isNoContent(schema.ast)) return false
969  const ast = Schema.toType(schema).ast
970  return (
971    SchemaAST.isObjects(ast) &&
972    ast.indexSignatures.length === 0 &&
973    ast.propertySignatures.length === 1 &&
974    ast.propertySignatures[0]?.name === "data"
975  )
976}
977 
978function isStreamSchema(schema: Schema.Top): schema is HttpApiSchema.StreamSchema {
979  return "_tag" in schema && (schema._tag === "StreamSse" || schema._tag === "StreamUint8Array")
980}
981 
982function streamDataSchema(schema: Extract<HttpApiSchema.StreamSchema, { readonly _tag: "StreamSse" }>) {
983  return Schema.make(streamDataAst(Schema.toType(schema.events).ast))
984}
985 
986function streamEncodedDataSchema(schema: Extract<HttpApiSchema.StreamSchema, { readonly _tag: "StreamSse" }>) {
987  const data = streamDataAst(schema.events.ast)
988  const encodedAst = data.encoding?.at(-1)?.to
989  if (encodedAst === undefined) throw new GenerationError({ reason: "Invalid SSE data schema" })
990  const encoded = resolveContentSchema(encodedAst)
991  if (!SchemaAST.isAST(encoded)) throw new GenerationError({ reason: "Invalid SSE data schema" })
992  return Schema.make(encoded)
993}
994 
995function streamDataAst(ast: SchemaAST.AST) {
996  if (!SchemaAST.isObjects(ast)) throw new GenerationError({ reason: "Invalid SSE data schema" })
997  const data = ast.propertySignatures.find((field) => field.name === "data")?.type
998  if (data === undefined) throw new GenerationError({ reason: "Invalid SSE data schema" })
999  return data
1000}
1001 
1002function streamEffectPortable(schema: Schema.Top) {
1003  if (!isStreamSchema(schema) || schema._tag === "StreamUint8Array" || schema.sseMode === "events") return true
1004  const rebuilt = HttpApiSchema.StreamSse({
1005    data: streamDataSchema(schema),
1006    error: schema.error,
1007    contentType: schema.contentType,
1008  })
1009  return sameEncoding(schema.events.ast, rebuilt.events.ast)
1010}
1011 
1012function renderGroup(group: Group, groupIndex: number) {
1013  const slots: Array<Slot> = []
1014  const adapters: Array<string> = []
1015  const endpointSources = group.endpoints.map((operation, endpointIndex) => {
1016    const {
1017      endpoint,
1018      errors,
1019      headers: endpointHeaders,
1020      params: endpointParams,
1021      payloads: endpointPayloads,
1022      query: endpointQuery,
1023      successes,
1024    } = operation
1025    const prefix = `Endpoint${endpointIndex}`
1026    const params = addSlot(endpointParams, `${prefix}Params`)
1027    const query = addSlot(endpointQuery, `${prefix}Query`)
1028    const headers = addSlot(endpointHeaders, `${prefix}Headers`)
1029    const payloads = endpointPayloads.map((schema, index) => addSlot(schema, `${prefix}Payload${index}`)!)
1030    const success = renderSuccess(successes[0], `${prefix}Success`)
1031    const errorSlots = errors.map((error, index) => addSlot(error.schema, `${prefix}Error${index}`)!)
1032    const options = [
1033      params === undefined ? undefined : `params: ${params.name}`,
1034      query === undefined ? undefined : `query: ${query.name}`,
1035      headers === undefined ? undefined : `headers: ${headers.name}`,
1036      payloads.length === 0
1037        ? undefined
1038        : `payload: ${payloads.length === 1 ? payloads[0].name : `[${payloads.map((slot) => slot.name).join(", ")}]`}`,
1039      `success: ${success.source}`,
1040      errorSlots.length === 0
1041        ? undefined
1042        : `error: ${errorSlots.length === 1 ? errorSlots[0].name : `[${errorSlots.map((slot) => slot.name).join(", ")}]`}`,
1043    ].filter((option): option is string => option !== undefined)
1044    const schemaBySource = { params, query, headers, payload: payloads[0] }
1045    const inputType = operation.input
1046      .map((field) => {
1047        const slot = schemaBySource[field.source]
1048        if (slot === undefined) {
1049          throw new GenerationError({ reason: `Missing input schema: ${group.identifier}.${endpoint.name}` })
1050        }
1051        return `readonly ${JSON.stringify(field.name)}${field.optional ? "?" : ""}: (typeof ${slot.name}.Type)[${JSON.stringify(field.name)}]`
1052      })
1053      .join("; ")
1054    const argument =
1055      operation.operation.inputMode === "none"
1056        ? ""
1057        : `input${operation.operation.inputMode === "optional" ? "?" : ""}: ${prefix}Input`
1058    const request = (["params", "query", "headers", "payload"] as const)
1059      .flatMap((source) => {
1060        const slot = schemaBySource[source]
1061        if (slot === undefined) return []
1062        const fields = operation.input
1063          .filter((field) => field.source === source)
1064          .map(
1065            (field) =>
1066              `${JSON.stringify(field.name)}: input${operation.operation.inputMode === "optional" ? "?." : ""}[${JSON.stringify(field.name)}]`,
1067          )
1068        return [`${source}: { ${fields.join(", ")} }`]
1069      })
1070      .join(", ")
1071    const declared = [...errorSlots, ...(success.streamError === undefined ? [] : [success.streamError])]
1072    const declaredSchema =
1073      declared.length === 0 ? "Schema.Never" : `Schema.Union([${declared.map((slot) => slot.name).join(", ")}])`
1074    const rawCall = `raw[${JSON.stringify(endpoint.name)}]({ ${request} })`
1075    const mapped = `${rawCall}.pipe(Effect.mapError(map${prefix}Error)${operation.unwrapData ? ", Effect.map((value) => value.data)" : ""})`
1076    const inputDeclaration = operation.operation.inputMode === "none" ? "" : `type ${prefix}Input = { ${inputType} }\n`
1077    adapters.push(
1078      `${inputDeclaration}const ${prefix}DeclaredError = ${declaredSchema}\nconst map${prefix}Error = (error: unknown) => HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error) ? new ClientError({ cause: error }) : Schema.is(${prefix}DeclaredError)(error) ? error : new ClientError({ cause: error })\nconst ${prefix} = (raw: RawGroup) => (${argument}) => ${operation.operation.success === "stream" ? `Stream.unwrap(${rawCall}.pipe(Effect.mapError(map${prefix}Error), Effect.map((stream) => stream.pipe(Stream.mapError(map${prefix}Error)))))` : mapped}`,
1079    )
1080    return `HttpApiEndpoint.make(${JSON.stringify(endpoint.method)})(${JSON.stringify(endpoint.name)}, ${JSON.stringify(endpoint.path)}, { ${options.join(", ")} })`
1081  })
1082 
1083  function addSlot(schema: Schema.Top | undefined, name: string) {
1084    if (schema === undefined) return undefined
1085    const slot = { name, schema }
1086    slots.push(slot)
1087    return slot
1088  }
1089 
1090  function renderSuccess(schema: Schema.Top, name: string) {
1091    if (!isStreamSchema(schema)) return { source: addSlot(schema, name)!.name }
1092    const status = resolveHttpApiStatus(schema.ast) ?? 200
1093    const annotate = status === 200 ? "" : `.pipe(HttpApiSchema.status(${status}))`
1094    if (schema._tag === "StreamUint8Array") {
1095      return {
1096        source: `HttpApiSchema.StreamUint8Array({ contentType: ${JSON.stringify(schema.contentType)} })${annotate}`,
1097      }
1098    }
1099    const value = addSlot(
1100      schema.sseMode === "data" ? streamDataSchema(schema) : schema.events,
1101      `${name}${schema.sseMode === "data" ? "Data" : "Events"}`,
1102    )!
1103    const error = addSlot(schema.error, `${name}Error`)!
1104    return {
1105      source: `HttpApiSchema.StreamSse({ ${schema.sseMode}: ${value.name}, error: ${error.name}, contentType: ${JSON.stringify(schema.contentType)} })${annotate}`,
1106      streamError: error,
1107    }
1108  }
1109 
1110  const declarations = renderSchemas(slots)
1111  const groupSource = `HttpApiGroup.make(${JSON.stringify(group.identifier)}, { topLevel: ${group.endpoints[0]?.topLevel ?? false} })${endpointSources.map((endpoint) => `.add(${endpoint})`).join("")}`
1112  const usesHttpApiSchema = endpointSources.some((source) => source.includes("HttpApiSchema."))
1113  const methods = group.endpoints
1114    .map((item, index) => `${JSON.stringify(item.operation.name)}: Endpoint${index}(raw)`)
1115    .join(", ")
1116  const rawGroup = group.endpoints[0]?.topLevel
1117    ? `HttpApiClient.Client<typeof Group${groupIndex}>`
1118    : `HttpApiClient.Client.Group<typeof Group${groupIndex}, ${JSON.stringify(group.identifier)}, never, never>`
1119  const usesStream = group.endpoints.some((item) => item.operation.success === "stream")
1120  return `// Generated by @opencode-ai/httpapi-codegen. Do not edit.\nimport { Effect, Schema${usesStream ? ", Stream" : ""} } from "effect"\nimport { Sse } from "effect/unstable/encoding"\nimport { HttpClientError } from "effect/unstable/http"\nimport { HttpApiClient, HttpApiEndpoint, HttpApiGroup${usesHttpApiSchema ? ", HttpApiSchema" : ""} } from "effect/unstable/httpapi"\nimport { ClientError } from "./client-error"\n\n${declarations}\n\nexport const Group${groupIndex} = ${groupSource}\n\ntype RawGroup = ${rawGroup}\n\n${adapters.join("\n\n")}\n\nexport const adaptGroup${groupIndex} = (raw: RawGroup) => ({ ${methods} })\n`
1121}
1122 
1123function renderSchemas(slots: ReadonlyArray<Slot>) {
1124  if (slots.length === 0) return ""
1125  const classes = new Map(
1126    slots.flatMap((slot, index) => {
1127      const tagged = taggedErrorFields(slot.schema)
1128      return tagged === undefined ? [] : [[index, tagged] as const]
1129    }),
1130  )
1131  const expanded = [
1132    ...slots.map((slot, index) => (classes.has(index) ? { name: slot.name, schema: Schema.Never } : slot)),
1133    ...Array.from(classes.values()).flatMap((tagged, classIndex) =>
1134      tagged.fields.map(([name, schema]) => ({ name: `Class${classIndex}${name}`, schema })),
1135    ),
1136  ]
1137  const [first, ...rest] = expanded
1138  const document = SchemaRepresentation.toCodeDocument(
1139    SchemaRepresentation.fromASTs([first.schema.ast, ...rest.map((slot) => slot.schema.ast)]),
1140  )
1141  const artifacts = document.artifacts.flatMap((artifact) => {
1142    if (artifact._tag === "Import") return [artifact.importDeclaration]
1143    if (artifact._tag === "Enum") return [artifact.generation.runtime]
1144    return [`const ${artifact.identifier} = ${artifact.generation.runtime}`]
1145  })
1146  const references = [
1147    ...document.references.nonRecursives.map(({ $ref, code }) => `const ${$ref} = ${code.runtime}`),
1148    ...Object.entries(document.references.recursives).map(
1149      ([$ref, code]) => `type ${$ref} = ${code.Type}\nconst ${$ref}: Schema.Codec<${$ref}> = ${code.runtime}`,
1150    ),
1151  ]
1152  let fieldIndex = slots.length
1153  const declarations = slots.map((slot, index) => {
1154    const tagged = classes.get(index)
1155    if (tagged === undefined) return `const ${slot.name} = ${document.codes[index].runtime}`
1156    const fields = tagged.fields
1157      .map(([name]) => `${JSON.stringify(name)}: ${document.codes[fieldIndex++].runtime}`)
1158      .join(", ")
1159    const annotations = Object.entries({
1160      httpApiStatus: resolveHttpApiStatus(slot.schema.ast),
1161      "~httpApiEncoding": resolveHttpApiEncoding(slot.schema.ast),
1162    }).filter((entry) => entry[1] !== undefined)
1163    const annotate =
1164      annotations.length === 0
1165        ? ""
1166        : `.annotate({ ${annotations.map(([key, value]) => `${JSON.stringify(key)}: ${JSON.stringify(value)}`).join(", ")} })`
1167    return `class ${slot.name}Class extends Schema.TaggedErrorClass<${slot.name}Class>(${JSON.stringify(tagged.identifier)})(${JSON.stringify(tagged.tag)}, { ${fields} }) {}\nconst ${slot.name} = ${slot.name}Class${annotate}`
1168  })
1169  return [...artifacts, ...references, ...declarations].join("\n\n")
1170}
1171 
1172function renderClient(groups: ReadonlyArray<Group>) {
1173  const imports = groups
1174    .map((group, index) => `import { adaptGroup${index}, Group${index} } from ${JSON.stringify(`./${group.module}`)}`)
1175    .join("\n")
1176  const api = `HttpApi.make("generated")${groups.map((_, index) => `.add(Group${index})`).join("")}`
1177  const fields = groups.flatMap((group, index) => {
1178    if (!group.endpoints[0]?.topLevel) {
1179      return [`${JSON.stringify(group.identifier)}: adaptGroup${index}(raw[${JSON.stringify(group.identifier)}])`]
1180    }
1181    const raw = `{ ${group.endpoints.map((item) => `${JSON.stringify(item.endpoint.name)}: raw[${JSON.stringify(item.endpoint.name)}]`).join(", ")} }`
1182    return [`...adaptGroup${index}(${raw})`]
1183  })
1184  return `// Generated by @opencode-ai/httpapi-codegen. Do not edit.\nimport { Effect } from "effect"\nimport { HttpApi, HttpApiClient } from "effect/unstable/httpapi"\n${imports}\n\nconst Api = ${api}\nconst adaptClient = (raw: HttpApiClient.ForApi<typeof Api>) => ({ ${fields.join(", ")} })\n\nexport const make = (options?: { readonly baseUrl?: URL | string }) =>\n  HttpApiClient.make(Api, options).pipe(Effect.map(adaptClient))\n`
1185}
1186