@syncular/typegen 0.1.3 → 0.2.0

package/src/emit-queries-swift.ts

@@ -0,0 +1,198 @@
+/**
+ * Swift named-query emitter: analyzed queries → a standalone
+ * `Syncular.queries.swift` file. Per query `q` it emits:
+ *
+ * - `struct QRow` + `init?(row:)` — the projection's OWN typed row (decoded
+ *   through the shared row helpers already in `Syncular.generated.swift`),
+ * - `enum <EnumName>Queries { static func q(client:params) -> [QRow] }` —
+ *   runs the query over the wrapper's positional `query(_:params:)`, binding
+ *   the named params in positional order,
+ * - `static let qTables` — the table-dependency set.
+ *
+ * It reuses the generated schema file's `SyncularSchemaRow` helpers (bool /
+ * bytes decode). Header carries the IR hash for byte-exact `--check`.
+ */
+import type { IrColumnType } from './ir';
+import type { AnalyzedQuery, QueryColumn } from './query';
+
+const SWIFT_TYPE: Readonly<Record<IrColumnType, string>> = {
+  string: 'String',
+  integer: 'Int',
+  float: 'Double',
+  boolean: 'Bool',
+  json: 'String',
+  bytes: '[UInt8]',
+  blob_ref: 'String',
+  crdt: '[UInt8]',
+};
+
+function pascalCase(name: string): string {
+  return name
+    .split(/[_-]+/)
+    .filter((p) => p.length > 0)
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+    .join('');
+}
+
+function camelCase(name: string): string {
+  const pascal = pascalCase(name);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+/** The query function/type name: already camelCase; PascalCase for the type. */
+function typeName(name: string): string {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+function quote(value: string): string {
+  return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function rowAccessor(column: QueryColumn): string {
+  const key = `row[${quote(column.name)}]`;
+  switch (column.type) {
+    case 'string':
+    case 'json':
+    case 'blob_ref':
+      return `${key}?.stringValue`;
+    case 'integer':
+      return `${key}?.numberValue.map(Int.init)`;
+    case 'float':
+      return `${key}?.numberValue`;
+    case 'boolean':
+      return `SyncularSchemaRow.bool(${key})`;
+    case 'bytes':
+    case 'crdt':
+      return `SyncularSchemaRow.bytes(${key})`;
+  }
+}
+
+function paramValue(type: IrColumnType, name: string): string {
+  switch (type) {
+    case 'integer':
+    case 'float':
+      return `.number(Double(${name}))`;
+    case 'boolean':
+      return `.bool(${name})`;
+    case 'bytes':
+    case 'crdt':
+      return `SyncularSchemaQueryBind.bytes(${name})`;
+    default:
+      return `.string(${name})`;
+  }
+}
+
+function emitRowStruct(query: AnalyzedQuery): string[] {
+  const Row = `${typeName(query.name)}Row`;
+  const lines: string[] = [];
+  lines.push(`/// One row of the ${query.name} query (its projection).`);
+  lines.push(`public struct ${Row}: Sendable, Equatable {`);
+  for (const column of query.columns) {
+    const opt = column.nullable ? '?' : '';
+    lines.push(
+      `    public let ${camelCase(column.name)}: ${SWIFT_TYPE[column.type]}${opt}`,
+    );
+  }
+  lines.push('');
+  lines.push('    public init?(row: [String: JSONValue]) {');
+  for (const column of query.columns) {
+    const name = camelCase(column.name);
+    const accessor = rowAccessor(column);
+    if (column.nullable) {
+      lines.push(`        self.${name} = ${accessor}`);
+    } else {
+      lines.push(`        guard let ${name} = ${accessor} else { return nil }`);
+      lines.push(`        self.${name} = ${name}`);
+    }
+  }
+  lines.push('    }');
+  lines.push('}');
+  return lines;
+}
+
+function emitRunner(query: AnalyzedQuery): string[] {
+  const Row = `${typeName(query.name)}Row`;
+  const lines: string[] = [];
+  lines.push(
+    `    public static let ${query.name}Tables = [${query.tables.map(quote).join(', ')}]`,
+  );
+  lines.push(
+    `    private static let ${query.name}Sql = ${quote(query.positionalSql)}`,
+  );
+  lines.push('');
+  lines.push(`    /// Run the ${query.name} named query (SELECT-only).`);
+  const args = query.params
+    .map((p) => `${camelCase(p.name)}: ${SWIFT_TYPE[p.type]}`)
+    .join(', ');
+  const signature =
+    query.params.length > 0
+      ? `client: SyncularClient, ${args}`
+      : 'client: SyncularClient';
+  lines.push(
+    `    public static func ${query.name}(${signature}) throws -> [${Row}] {`,
+  );
+  if (query.params.length > 0) {
+    const binds = query.params
+      .map((p) => paramValue(p.type, camelCase(p.name)))
+      .join(', ');
+    lines.push(`        let params: [JSONValue] = [${binds}]`);
+    lines.push(
+      `        return try client.query(${query.name}Sql, params: params).compactMap { row in`,
+    );
+  } else {
+    lines.push(
+      `        return try client.query(${query.name}Sql).compactMap { row in`,
+    );
+  }
+  lines.push(
+    '            guard case let .object(fields) = row else { return nil }',
+  );
+  lines.push(`            return ${Row}(row: fields)`);
+  lines.push('        }');
+  lines.push('    }');
+  return lines;
+}
+
+export function emitQueriesSwiftModule(
+  queries: readonly AnalyzedQuery[],
+  hash: string,
+  irVersion: number,
+  enumName: string,
+): string {
+  const parts: string[] = [];
+  parts.push(
+    [
+      '// Generated by @syncular/typegen — DO NOT EDIT.',
+      `// irVersion: ${irVersion}`,
+      `// irHash: ${hash}`,
+      '',
+      'import Foundation',
+      'import Syncular',
+    ].join('\n'),
+  );
+
+  parts.push(
+    [
+      '/// Param-bind helpers shared by the generated query runners.',
+      'enum SyncularSchemaQueryBind {',
+      '    static func bytes(_ value: [UInt8]) -> JSONValue {',
+      '        let hex = value.map { String(format: "%02x", $0) }.joined()',
+      '        return .object(["$bytes": .string(hex)])',
+      '    }',
+      '}',
+    ].join('\n'),
+  );
+
+  for (const query of queries) {
+    parts.push(emitRowStruct(query).join('\n'));
+  }
+
+  const enumLines: string[] = [];
+  enumLines.push('/// Typed named queries (the sqlc/SQLDelight tier).');
+  enumLines.push(`public enum ${enumName}Queries {`);
+  enumLines.push(queries.map((q) => emitRunner(q).join('\n')).join('\n\n'));
+  enumLines.push('}');
+  parts.push(enumLines.join('\n'));
+
+  return `${parts.join('\n\n')}\n`;
+}

package/src/emit-queries.ts

@@ -0,0 +1,183 @@
+/**
+ * TS named-query emitter: analyzed queries → a standalone
+ * `syncular.queries.ts` module. Per query `q` it emits:
+ *
+ * - `QRow` — the projection row interface (its OWN type per query — the
+ *   drift-kill: the row shape is exactly what the SELECT returns),
+ * - `QParams` — the typed params object (when the query has params),
+ * - `qTables` — the readonly table-dependency set (feeds useSyncQuery `{tables}`
+ *   for EXACT invalidation),
+ * - `q(client, params?): Promise<QRow[]>` — runs the query over the wrapper's
+ *   positional `query(sql, params[])` surface, reordering the named params
+ *   object into the positional array the wire expects.
+ *
+ * A tiny structural `QueryClient` interface (just `query(sql, params?)`) keeps
+ * the module import-free — it structurally accepts `SyncClientLike` /
+ * `SyncClient` / `SyncClientHandle` alike. Header carries the IR hash so
+ * `--check` gates freshness byte-exactly, like every other emitter.
+ */
+import type { IrColumnType } from './ir';
+import type { AnalyzedQuery } from './query';
+
+const TS_TYPE: Readonly<Record<IrColumnType, string>> = {
+  string: 'string',
+  integer: 'number',
+  float: 'number',
+  boolean: 'boolean',
+  json: 'string',
+  bytes: 'Uint8Array',
+  blob_ref: 'string',
+  crdt: 'Uint8Array',
+};
+
+function pascalCase(name: string): string {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+function quote(value: string): string {
+  return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function propertyKey(name: string): string {
+  return IDENTIFIER_RE.test(name) ? name : quote(name);
+}
+
+/** A named-query param value is the SqlValue subset its type maps to. */
+const PARAM_TS_TYPE: Readonly<Record<IrColumnType, string>> = TS_TYPE;
+
+function emitQuery(query: AnalyzedQuery): string {
+  const Row = `${pascalCase(query.name)}Row`;
+  const Params = `${pascalCase(query.name)}Params`;
+  const lines: string[] = [];
+
+  // Row interface.
+  lines.push(
+    `/** One row of the ${quote(query.name)} query (its projection). */`,
+  );
+  lines.push(`export interface ${Row} {`);
+  for (const column of query.columns) {
+    lines.push(
+      `  ${propertyKey(column.name)}: ${TS_TYPE[column.type]}${column.nullable ? ' | null' : ''};`,
+    );
+  }
+  lines.push('}');
+  lines.push('');
+
+  // Params interface (only when there are params).
+  const hasParams = query.params.length > 0;
+  if (hasParams) {
+    lines.push(`/** Named parameters for ${quote(query.name)}. */`);
+    lines.push(`export interface ${Params} {`);
+    for (const param of query.params) {
+      lines.push(`  ${propertyKey(param.name)}: ${PARAM_TS_TYPE[param.type]};`);
+    }
+    lines.push('}');
+    lines.push('');
+  }
+
+  // Tables dependency set (for useSyncQuery {tables} / useNamedQuery).
+  lines.push(
+    `/** Tables ${quote(query.name)} reads — the exact useSyncQuery \`{tables}\` set. */`,
+  );
+  lines.push(
+    `export const ${query.name}Tables = [${query.tables.map(quote).join(', ')}] as const;`,
+  );
+  lines.push('');
+
+  // The runner. SQL is the positional form; params reorder into the array.
+  const paramArg = hasParams ? `params: ${Params}` : '';
+  const sqlConst = `${query.name}Sql`;
+  const positional = hasParams
+    ? `[${query.params.map((p) => `params.${propertyKey(p.name)}`).join(', ')}]`
+    : '[]';
+  lines.push(`const ${sqlConst} = ${quote(query.positionalSql)};`);
+  lines.push('');
+  lines.push(`/** Run the ${quote(query.name)} named query (SELECT-only). */`);
+  lines.push(
+    `export async function ${query.name}(client: QueryClient${hasParams ? `, ${paramArg}` : ''}): Promise<${Row}[]> {`,
+  );
+  if (hasParams) {
+    lines.push(
+      `  const rows = await client.query(${sqlConst}, ${positional});`,
+    );
+  } else {
+    lines.push(`  const rows = await client.query(${sqlConst});`);
+  }
+  lines.push(`  return rows as unknown as ${Row}[];`);
+  lines.push('}');
+  lines.push('');
+
+  // A descriptor for react's `useNamedQuery` — the SQL, the exact table
+  // dependency set, and a `bind(params)` → positional array. Typed by the
+  // query's own Row/Params so the hook stays fully typed.
+  lines.push(
+    `/** Descriptor for \`useNamedQuery(${query.name}Query${hasParams ? ', params' : ''})\` — sql + tables + row type. */`,
+  );
+  const paramsTypeArg = hasParams ? Params : 'undefined';
+  lines.push(
+    `export const ${query.name}Query: NamedQuery<${Row}, ${paramsTypeArg}> = {`,
+  );
+  lines.push(`  sql: ${sqlConst},`);
+  lines.push(`  tables: ${query.name}Tables,`);
+  if (hasParams) {
+    lines.push(`  bind: (params: ${Params}) => ${positional},`);
+  } else {
+    lines.push('  bind: () => [],');
+  }
+  lines.push('};');
+  return lines.join('\n');
+}
+
+export function emitQueriesModule(
+  queries: readonly AnalyzedQuery[],
+  hash: string,
+  irVersion: number,
+): string {
+  const parts: string[] = [];
+  parts.push(
+    [
+      '// Generated by @syncular/typegen — DO NOT EDIT.',
+      `// irVersion: ${irVersion}`,
+      `// irHash: ${hash}`,
+    ].join('\n'),
+  );
+  parts.push(
+    [
+      "/** A bindable SQL param/row value (the wrapper's SqlValue subset). */",
+      'export type QueryValue =',
+      '  | string',
+      '  | number',
+      '  | bigint',
+      '  | boolean',
+      '  | Uint8Array',
+      '  | null;',
+      '',
+      "/** Minimal structural client surface — the wrapper's positional",
+      ' *  `query(sql, params?)`. `SyncClient`/`SyncClientHandle`/`SyncClientLike`',
+      ' *  all satisfy it, so this module imports nothing. */',
+      'export interface QueryClient {',
+      '  query(',
+      '    sql: string,',
+      '    params?: readonly QueryValue[],',
+      '  ): unknown[] | Promise<unknown[]>;',
+      '}',
+      '',
+      '/** A named-query descriptor — sql + its exact table dependency set + a',
+      ' *  `bind(params)` → positional args. Consumed by',
+      " *  `@syncular/react`'s `useNamedQuery`. `Row` is the projection row",
+      ' *  type; `Params` is `undefined` for a param-less query. */',
+      'export interface NamedQuery<Row, Params = undefined> {',
+      '  readonly sql: string;',
+      '  readonly tables: readonly string[];',
+      '  readonly bind: (params: Params) => readonly QueryValue[];',
+      '  /** Phantom — carries the Row type for `useNamedQuery` inference. */',
+      '  readonly __row?: Row;',
+      '}',
+    ].join('\n'),
+  );
+  for (const query of queries) {
+    parts.push(emitQuery(query));
+  }
+  return `${parts.join('\n\n')}\n`;
+}

package/src/emit-swift.ts

@@ -0,0 +1,295 @@
+/**
+ * Swift emitter: neutral IR → one standalone `.swift` file exporting
+ *
+ * - `enum <EnumName> { static let schema: JSONValue }` — the ServerSchema
+ *   object, built from the IR with byte-stable ordering (fed straight into
+ *   `SyncularClient(schema:)`),
+ * - one `struct` per table with typed properties (per the six §2.4 column
+ *   types, plus blob_ref/crdt in their honest Swift shapes) and a
+ *   `init?(row:)` from a `[String: JSONValue]` (the shape `query`/`readRows`
+ *   return),
+ * - a `subscriptions` namespace of typed requested-scope builders.
+ *
+ * The file imports only `Syncular` (for `JSONValue`). The header carries the
+ * IR hash so `--check` verifies freshness byte-exactly, exactly like the TS
+ * emitter.
+ */
+import type { IrColumnType, IrDocument, IrSubscription, IrTable } from './ir';
+
+/**
+ * §2.4 column type → honest Swift type. `json`/`blob_ref` are the raw
+ * canonical JSON string (the client's blob API parses blob_ref); `bytes`/
+ * `crdt` are opaque `[UInt8]`.
+ */
+const SWIFT_TYPE: Readonly<Record<IrColumnType, string>> = {
+  string: 'String',
+  integer: 'Int',
+  float: 'Double',
+  boolean: 'Bool',
+  json: 'String',
+  bytes: '[UInt8]',
+  blob_ref: 'String',
+  crdt: '[UInt8]',
+};
+
+/** §5.11: app-side Swift type — declaredType for an encrypted column. */
+function appSwiftType(column: IrTable['columns'][number]): string {
+  const type =
+    column.encrypted === true && column.declaredType !== undefined
+      ? column.declaredType
+      : column.type;
+  return SWIFT_TYPE[type];
+}
+
+function pascalCase(name: string): string {
+  return name
+    .split(/[_-]+/)
+    .filter((part) => part.length > 0)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}
+
+function camelCase(name: string): string {
+  const pascal = pascalCase(name);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function quote(value: string): string {
+  return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+/** Emit a `JSONValue` literal for the schema object (built from the IR). */
+function emitSchemaValue(ir: IrDocument, indent: string): string[] {
+  const lines: string[] = [];
+  const i = indent;
+  lines.push(`${i}.object([`);
+  lines.push(`${i}  "version": .number(${ir.schemaVersion}),`);
+  lines.push(`${i}  "tables": .array([`);
+  for (const table of ir.tables) {
+    lines.push(`${i}    .object([`);
+    lines.push(`${i}      "name": .string(${quote(table.name)}),`);
+    lines.push(`${i}      "primaryKey": .string(${quote(table.primaryKey)}),`);
+    lines.push(`${i}      "columns": .array([`);
+    for (const column of table.columns) {
+      const parts = [
+        `"name": .string(${quote(column.name)})`,
+        `"type": .string(${quote(column.type)})`,
+        `"nullable": .bool(${column.nullable})`,
+      ];
+      if (column.crdtType !== undefined) {
+        parts.push(`"crdtType": .string(${quote(column.crdtType)})`);
+      }
+      if (column.encrypted === true) {
+        parts.push('"encrypted": .bool(true)');
+        parts.push(
+          `"declaredType": .string(${quote(column.declaredType ?? column.type)})`,
+        );
+      }
+      lines.push(`${i}        .object([${parts.join(', ')}]),`);
+    }
+    lines.push(`${i}      ]),`);
+    lines.push(`${i}      "scopes": .array([`);
+    for (const scope of table.scopes) {
+      lines.push(
+        `${i}        .object(["pattern": .string(${quote(scope.pattern)}), "column": .string(${quote(scope.column)})]),`,
+      );
+    }
+    lines.push(`${i}      ]),`);
+    lines.push(`${i}    ]),`);
+  }
+  lines.push(`${i}  ]),`);
+  lines.push(`${i}])`);
+  return lines;
+}
+
+/** The accessor that lifts a §2.4 value out of a `[String: JSONValue]` row. */
+function rowAccessor(column: {
+  type: IrColumnType;
+  name: string;
+  nullable: boolean;
+}): string {
+  const key = `row[${quote(column.name)}]`;
+  switch (column.type) {
+    case 'string':
+    case 'json':
+    case 'blob_ref':
+      return `${key}?.stringValue`;
+    case 'integer':
+      // SQLite integers ride as JSON numbers; round to Int. Uses `.map(Int.init)`
+      // (not a trailing closure) so it parses inside a `guard let … else`.
+      return `${key}?.numberValue.map(Int.init)`;
+    case 'float':
+      return `${key}?.numberValue`;
+    case 'boolean':
+      // SQLite has no bool: it stores 0/1. Accept a real JSON bool OR 0/1.
+      return `SyncularSchemaRow.bool(${key})`;
+    case 'bytes':
+    case 'crdt':
+      // The core marshals bytes as {"$bytes":"<hex>"}; decode to [UInt8].
+      return `SyncularSchemaRow.bytes(${key})`;
+  }
+}
+
+function emitStruct(table: IrTable): string[] {
+  const type = pascalCase(table.name);
+  const lines: string[] = [];
+  lines.push(`/// One ${table.name} row (§2.4 column order).`);
+  lines.push(`public struct ${type}: Sendable, Equatable {`);
+  for (const column of table.columns) {
+    const swift = appSwiftType(column);
+    const opt = column.nullable ? '?' : '';
+    lines.push(`    public let ${camelCase(column.name)}: ${swift}${opt}`);
+  }
+  lines.push('');
+  // Memberwise init (public, so app code can build rows too).
+  const params = table.columns
+    .map((c) => {
+      const swift = SWIFT_TYPE[c.type];
+      const opt = c.nullable ? '? = nil' : '';
+      return `${camelCase(c.name)}: ${swift}${opt}`;
+    })
+    .join(', ');
+  lines.push(`    public init(${params}) {`);
+  for (const column of table.columns) {
+    const name = camelCase(column.name);
+    lines.push(`        self.${name} = ${name}`);
+  }
+  lines.push('    }');
+  lines.push('');
+  lines.push(
+    `    /// Build from a \`query\`/\`readRows\` row (\`[String: JSONValue]\`).`,
+  );
+  lines.push(
+    `    /// Returns nil when a non-nullable column is missing or mistyped.`,
+  );
+  lines.push('    public init?(row: [String: JSONValue]) {');
+  for (const column of table.columns) {
+    const name = camelCase(column.name);
+    const accessor = rowAccessor(column);
+    if (column.nullable) {
+      lines.push(`        self.${name} = ${accessor}`);
+    } else {
+      lines.push(`        guard let ${name} = ${accessor} else { return nil }`);
+      lines.push(`        self.${name} = ${name}`);
+    }
+  }
+  lines.push('    }');
+  lines.push('}');
+  return lines;
+}
+
+function emitSubscription(sub: IrSubscription): string[] {
+  const params: string[] = [];
+  for (const scope of sub.scopes) {
+    for (const value of scope.values) {
+      if (value.kind === 'parameter' && !params.includes(value.name)) {
+        params.push(value.name);
+      }
+    }
+  }
+  const lines: string[] = [];
+  lines.push(
+    `        /// Requested-scope template for the ${quote(sub.name)} subscription.`,
+  );
+  lines.push(`        public enum ${pascalCase(sub.name)} {`);
+  lines.push(`            public static let name = ${quote(sub.name)}`);
+  lines.push(`            public static let table = ${quote(sub.table)}`);
+  const args = params.map((p) => `${camelCase(p)}: String`).join(', ');
+  lines.push(
+    `            public static func scopes(${args}) -> [String: [String]] {`,
+  );
+  lines.push('                [');
+  for (const scope of sub.scopes) {
+    const values = scope.values
+      .map((value) =>
+        value.kind === 'literal' ? quote(value.value) : camelCase(value.name),
+      )
+      .join(', ');
+    lines.push(`                    ${quote(scope.variable)}: [${values}],`);
+  }
+  lines.push('                ]');
+  lines.push('            }');
+  lines.push('        }');
+  return lines;
+}
+
+export function emitSwiftModule(
+  ir: IrDocument,
+  hash: string,
+  enumName: string,
+): string {
+  const parts: string[] = [];
+  parts.push(
+    [
+      '// Generated by @syncular/typegen — DO NOT EDIT.',
+      `// irVersion: ${ir.irVersion}`,
+      `// irHash: ${hash}`,
+      '',
+      'import Foundation',
+      'import Syncular',
+    ].join('\n'),
+  );
+
+  // The schema namespace.
+  const schemaLines: string[] = [];
+  schemaLines.push(
+    `/// The generated syncular schema (SPEC §2.4, §3.1) + typed rows.`,
+  );
+  schemaLines.push(`public enum ${enumName} {`);
+  schemaLines.push(
+    `    /// ServerSchema-compatible schema — pass to \`SyncularClient(schema:)\`.`,
+  );
+  schemaLines.push('    public static let schema: JSONValue =');
+  for (const line of emitSchemaValue(ir, '        ')) {
+    schemaLines.push(line);
+  }
+  schemaLines.push('');
+  // Subscriptions namespace nested in the schema enum.
+  schemaLines.push('    /// Typed requested-scope builders per subscription.');
+  schemaLines.push('    public enum subscriptions {');
+  if (ir.subscriptions.length === 0) {
+    schemaLines.push('        // (no subscriptions declared)');
+  }
+  for (const sub of ir.subscriptions) {
+    for (const line of emitSubscription(sub)) schemaLines.push(line);
+  }
+  schemaLines.push('    }');
+  schemaLines.push('}');
+  parts.push(schemaLines.join('\n'));
+
+  // Shared row-decode helpers (0/1 booleans, {$bytes} decode).
+  parts.push(
+    [
+      '/// Row-decode helpers shared by the generated structs.',
+      'enum SyncularSchemaRow {',
+      '    /// Lift a SQLite boolean: a real JSON bool, or 0/1 as a number.',
+      '    static func bool(_ value: JSONValue?) -> Bool? {',
+      '        if let b = value?.boolValue { return b }',
+      '        if let n = value?.numberValue { return n != 0 }',
+      '        return nil',
+      '    }',
+      '',
+      '    /// Decode the core\'s `{"$bytes":"<hex>"}` marshaling into bytes.',
+      '    static func bytes(_ value: JSONValue?) -> [UInt8]? {',
+      '        guard let hex = value?["$bytes"]?.stringValue else { return nil }',
+      '        var out: [UInt8] = []',
+      '        out.reserveCapacity(hex.count / 2)',
+      '        var index = hex.startIndex',
+      '        while index < hex.endIndex {',
+      '            let next = hex.index(index, offsetBy: 2, limitedBy: hex.endIndex) ?? hex.endIndex',
+      '            guard let byte = UInt8(hex[index..<next], radix: 16) else { return nil }',
+      '            out.append(byte)',
+      '            index = next',
+      '        }',
+      '        return out',
+      '    }',
+      '}',
+    ].join('\n'),
+  );
+
+  for (const table of ir.tables) {
+    parts.push(emitStruct(table).join('\n'));
+  }
+
+  return `${parts.join('\n\n')}\n`;
+}