@exornea/zeno-compiler 1.7.0 → 2.2.0

package/dist/emitter.js

@@ -1,10 +1,20 @@
 import { scalarGetterMethod, scalarSetterMethod, scalarTsType, } from "@exornea/zeno-schema";
-import { canWriteFixedArrayStructElement, collectFixedArrayRuntimeImports, emitFixedArrayFieldAccessor, emitFixedArrayObjectFieldWrite, fixedArrayInputElementType, } from "./emitter-fixed-array.js";
+import { emitFixedArrayFieldAccessor, emitFixedArrayObjectFieldWrite, } from "./emitter-fixed-array.js";
+import { emitAstCheckedSource } from "./emitter-ast.js";
+import { canEmitObjectWriter, hasTailWriterFields, isTailWriterField, structFieldHasTailFields, } from "./emitter-capabilities.js";
+import { emitInputInterface } from "./emitter-input.js";
+import { encodingLiteral, toLittleEndianLiteral, toPascalCase } from "./emitter-names.js";
+import { collectRuntimeImports } from "./emitter-runtime-imports.js";
+import { emitScalarScanKernels, emitScanRangeHelper, hasScanKernels, normalizeScanKernelMode, } from "./emitter-scan-kernels.js";
 import { method } from "./emitter-template.js";
+import { createProjectionSourceMap } from "./source-map.js";
 export function emitStructView(layout, options = {}) {
     return emitProjectionFile([layout], options);
 }
 export function emitProjectionFile(layouts, options = {}) {
+    return emitAstCheckedSource(emitProjectionFileText(layouts, options), "zeno.view.ts").code;
+}
+function emitProjectionFileText(layouts, options = {}) {
     const lines = [];
     const runtimeImports = collectRuntimeImports(layouts);
     const layoutMap = new Map(layouts.map((layout) => [layout.name, layout]));
@@ -20,109 +30,13 @@ export function emitProjectionFile(layouts, options = {}) {
     }
     return lines.join("\n");
 }
-function collectRuntimeImports(layouts) {
-    const imports = new Set(["ProjectionView"]);
-    const layoutMap = new Map(layouts.map((layout) => [layout.name, layout]));
-    for (const layout of layouts) {
-        if (hasTailWriterFields(layout, layoutMap)) {
-            imports.add("DynamicLayoutWriter");
-        }
-        for (const field of layout.fields) {
-            collectFieldRuntimeImports(field, imports);
-        }
-    }
-    return Array.from(imports).sort();
-}
-function collectFieldRuntimeImports(field, imports) {
-    switch (field.kind) {
-        case "fixed-bytes":
-            imports.add("fixedBytesView");
-            imports.add("writeFixedBytes");
-            return;
-        case "fixed-string":
-            imports.add("decodeFixedText");
-            imports.add("fixedBytesView");
-            imports.add("writeFixedText");
-            return;
-        case "dynamic-string":
-            imports.add("Utf8SpanView");
-            return;
-        case "dynamic-bytes":
-            imports.add("BytesSpanView");
-            return;
-        case "vector":
-            switch (field.element.kind) {
-                case "scalar":
-                    imports.add("ScalarVectorView");
-                    return;
-                case "dynamic-string":
-                    imports.add("Utf8VectorView");
-                    return;
-                case "dynamic-bytes":
-                    imports.add("BytesVectorView");
-                    return;
-                case "fixed-bytes":
-                    imports.add("FixedBytesVectorView");
-                    return;
-                case "fixed-string":
-                    imports.add("FixedStringVectorView");
-                    return;
-                case "struct":
-                    imports.add("StructVectorView");
-                    return;
-                case "pointer":
-                    imports.add("PointerVectorView");
-                    return;
-                default:
-                    return;
-            }
-        case "fixed-array":
-            collectFixedArrayRuntimeImports(field.element, imports);
-            return;
-        default:
-            return;
-    }
-}
-function emitInputInterface(layout) {
-    const lines = [`export interface ${layout.name}ViewInput {`];
-    for (const field of layout.fields) {
-        lines.push(`  readonly ${field.name}: ${fieldInputType(field)};`);
-    }
-    lines.push("}");
-    return lines;
-}
-function fieldInputType(field) {
-    switch (field.kind) {
-        case "scalar":
-            return scalarTsType(field.scalar);
-        case "fixed-bytes":
-        case "dynamic-bytes":
-            return "ArrayLike<number> | Uint8Array";
-        case "fixed-string":
-        case "dynamic-string":
-            return "string";
-        case "struct":
-            return `${field.typeName}ViewInput`;
-        case "pointer":
-            return "number | null";
-        case "fixed-array":
-            return `readonly ${fixedArrayInputElementType(field.element)}[]`;
-        case "vector":
-            switch (field.element.kind) {
-                case "scalar":
-                    return `readonly ${scalarTsType(field.element.scalar)}[]`;
-                case "fixed-bytes":
-                case "dynamic-bytes":
-                    return "readonly (ArrayLike<number> | Uint8Array)[]";
-                case "fixed-string":
-                case "dynamic-string":
-                    return "readonly string[]";
-                case "struct":
-                    return `readonly ${field.element.typeName}ViewInput[]`;
-                case "pointer":
-                    return "readonly (number | null)[]";
-            }
-    }
+export function emitProjectionFileWithSourceMap(layouts, generatedFile, options = {}) {
+    const sourceMapUrl = `${generatedFile.split(/[\\/]/).pop() ?? generatedFile}.map`;
+    const code = `${emitAstCheckedSource(emitProjectionFileText(layouts, options), generatedFile).code}\n//# sourceMappingURL=${sourceMapUrl}\n`;
+    return {
+        code,
+        sourceMap: createProjectionSourceMap(code, layouts, generatedFile),
+    };
 }
 function emitLayoutConstants(layout) {
     const lines = [];
@@ -134,8 +48,8 @@ function emitLayoutConstants(layout) {
     return lines;
 }
 function emitStructClass(layout, options, layoutMap) {
-    const scalarFields = layout.fields.filter((field) => field.kind === "scalar");
     const littleEndianDefault = toLittleEndianLiteral(layout);
+    const scanKernelMode = normalizeScanKernelMode(options.scanKernels);
     const lines = [`export class ${layout.name}View extends ProjectionView {`];
     lines.push(...method `
 static readonly byteLength = ${layout.byteLength};
@@ -162,60 +76,25 @@ private static assertPointerTargetRange(view: DataView, targetOffset: number, by
   }
 }`);
     }
-    if (options.optimizeCursorOffsets && scalarFields.length > 0) {
+    if (hasScanKernels(layout, scanKernelMode)) {
         lines.push("");
-        lines.push(...method `${scalarFields.map((field) => `private $${field.name}Offset = ${field.offset};`)}`);
+        lines.push(...emitScanRangeHelper(layout));
     }
     lines.push("");
-    if (options.optimizeCursorOffsets && scalarFields.length > 0) {
-        lines.push(...method `
-constructor(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}) {
-  super(view, baseOffset, littleEndian);
-  this.$refreshOffsets();
-}
-
-private $refreshOffsets(): void {
-${scalarFields.map((field) => `  this.$${field.name}Offset = this.baseOffset + ${field.offset};`)}
-}
-
-override rebase(baseOffset: number): this {
-  super.rebase(baseOffset);
-  this.$refreshOffsets();
-  return this;
-}
-
-override rebaseUnchecked(baseOffset: number): this {
-  super.rebaseUnchecked(baseOffset);
-  this.$refreshOffsets();
-  return this;
-}`);
-    }
-    else {
-        lines.push(...method `
+    lines.push(...method `
 constructor(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}) {
   super(view, baseOffset, littleEndian);
 }`);
-    }
     lines.push("");
     lines.push(...method `
 static at(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): ${layout.name}View {
   return new ${layout.name}View(view, baseOffset, littleEndian);
 }`);
     lines.push("");
-    if (options.optimizeCursorOffsets && scalarFields.length > 0) {
-        lines.push(...method `
-moveTo(index: number): this {
-  this.moveToIndex(index, ${layout.name}View.byteLength);
-  this.$refreshOffsets();
-  return this;
-}`);
-    }
-    else {
-        lines.push(...method `
+    lines.push(...method `
 moveTo(index: number): this {
   return this.moveToIndex(index, ${layout.name}View.byteLength);
 }`);
-    }
     lines.push("");
     lines.push(...method `
 moveToUnchecked(index: number): this {
@@ -237,14 +116,14 @@ moveToUnchecked(index: number): this {
         lines.push("");
     }
     for (const field of layout.fields) {
-        const staticAccessorLines = emitStaticFieldAccessor(layout, field);
+        const staticAccessorLines = emitStaticFieldAccessor(layout, field, scanKernelMode);
         for (const line of staticAccessorLines) {
             lines.push(line);
         }
         if (staticAccessorLines.length > 0) {
             lines.push("");
         }
-        for (const line of emitField(layout, field, options)) {
+        for (const line of emitField(layout, field)) {
             lines.push(line);
         }
         lines.push("");
@@ -315,6 +194,18 @@ static write${pascalName}(writer: DynamicLayoutWriter, values: readonly ${scalar
         return method `
 static write${pascalName}(writer: DynamicLayoutWriter, values: readonly ${field.element.typeName}ViewInput[]) {
   return writer.writeStructVector(${layout.name}View.${field.name}Offset, values, ${field.element.byteLength}, (view, value, baseOffset, littleEndian) => ${field.element.typeName}View.write(view, value, baseOffset, littleEndian), ${alignment});
+}`;
+    },
+    "dynamic-struct": ({ layout, layoutMap, field, pascalName }) => {
+        const elementLayout = layoutMap.get(field.element.typeName);
+        const alignment = elementLayout?.alignment ?? 1;
+        const elementByteLength = elementLayout?.byteLength ?? field.element.byteLength;
+        const writeElement = elementLayout !== undefined && hasTailWriterFields(elementLayout, layoutMap)
+            ? `${field.element.typeName}View.writeInto(view, elementWriter, value, baseOffset, littleEndian)`
+            : `${field.element.typeName}View.write(view, value, baseOffset, littleEndian)`;
+        return method `
+static write${pascalName}(writer: DynamicLayoutWriter, values: readonly ${field.element.typeName}ViewInput[]) {
+  return writer.writeDynamicStructVector(${layout.name}View.${field.name}Offset, values, ${elementByteLength}, (view, elementWriter, value, baseOffset, littleEndian) => ${writeElement}, ${alignment});
 }`;
     },
     pointer: ({ layout, field, pascalName }) => method `
@@ -334,20 +225,28 @@ function emitObjectWriterMethod(layout, layoutMap) {
     const returnType = hasTailFields ? "DynamicLayoutWriter" : "void";
     const bodyLines = [];
     if (hasTailFields) {
-        bodyLines.push(`  const writer = ${layout.name}View.createWriter(view, baseOffset, ${layout.name}View.byteLength, littleEndian);`);
-    }
-    for (const field of layout.fields) {
-        bodyLines.push(...emitObjectFieldWrite(layout, field));
+        bodyLines.push(`  const writer = ${layout.name}View.createWriter(view, baseOffset, ${layout.name}View.byteLength, littleEndian);`, `  ${layout.name}View.writeInto(view, writer, value, baseOffset, littleEndian);`, "  return writer;");
     }
-    if (hasTailFields) {
-        bodyLines.push("  return writer;");
+    else {
+        for (const field of layout.fields) {
+            bodyLines.push(...emitObjectFieldWrite(layout, layoutMap, field));
+        }
     }
-    return method `
+    const lines = method `
 static write(view: DataView, value: ${layout.name}ViewInput, baseOffset = 0, littleEndian = ${toLittleEndianLiteral(layout)}): ${returnType} {
 ${bodyLines}
 }`;
+    if (hasTailFields) {
+        const writeIntoLines = layout.fields.flatMap((field) => emitObjectFieldWriteAtBase(layout, layoutMap, field));
+        lines.push("");
+        lines.push(...method `
+static writeInto(view: DataView, writer: DynamicLayoutWriter, value: ${layout.name}ViewInput, baseOffset = 0, littleEndian = ${toLittleEndianLiteral(layout)}): void {
+${writeIntoLines}
+}`);
+    }
+    return lines;
 }
-function emitObjectFieldWrite(layout, field) {
+function emitObjectFieldWrite(layout, layoutMap, field) {
     const pascalName = toPascalCase(field.name);
     switch (field.kind) {
         case "scalar":
@@ -366,6 +265,11 @@ function emitObjectFieldWrite(layout, field) {
         case "dynamic-bytes":
             return [`  ${layout.name}View.write${pascalName}(writer, value.${field.name});`];
         case "struct":
+            if (structFieldHasTailFields(layoutMap, field.typeName)) {
+                return [
+                    `  ${field.typeName}View.writeInto(view, writer, value.${field.name}, baseOffset + ${field.offset}, littleEndian);`,
+                ];
+            }
             return [
                 `  ${field.typeName}View.write(view, value.${field.name}, baseOffset + ${field.offset}, littleEndian);`,
             ];
@@ -379,13 +283,140 @@ function emitObjectFieldWrite(layout, field) {
             return [`  ${layout.name}View.write${pascalName}(writer, value.${field.name});`];
     }
 }
-function emitStaticFieldAccessor(layout, field) {
+function emitObjectFieldWriteAtBase(layout, layoutMap, field) {
+    const pascalName = toPascalCase(field.name);
+    switch (field.kind) {
+        case "scalar":
+            return [
+                `  ${layout.name}View.set${pascalName}(view, value.${field.name}, baseOffset, littleEndian);`,
+            ];
+        case "fixed-bytes":
+            return [
+                `  writeFixedBytes(view.buffer, view.byteOffset + baseOffset + ${field.offset}, ${field.byteLength}, value.${field.name});`,
+            ];
+        case "fixed-string":
+            return [
+                `  writeFixedText(view.buffer, view.byteOffset + baseOffset + ${field.offset}, ${field.byteLength}, value.${field.name}, ${encodingLiteral(field.encoding)});`,
+            ];
+        case "dynamic-string":
+            return [
+                `  writer.writeTextAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name}, ${encodingLiteral(field.encoding)});`,
+            ];
+        case "dynamic-bytes":
+            return [
+                `  writer.writeBytesAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name});`,
+            ];
+        case "struct":
+            if (structFieldHasTailFields(layoutMap, field.typeName)) {
+                return [
+                    `  ${field.typeName}View.writeInto(view, writer, value.${field.name}, baseOffset + ${field.offset}, littleEndian);`,
+                ];
+            }
+            return [
+                `  ${field.typeName}View.write(view, value.${field.name}, baseOffset + ${field.offset}, littleEndian);`,
+            ];
+        case "pointer":
+            return [
+                `  ${layout.name}View.set${pascalName}TargetOffset(view, value.${field.name}, baseOffset, littleEndian);`,
+            ];
+        case "fixed-array":
+            return emitFixedArrayObjectFieldWrite(field, encodingLiteral);
+        case "vector":
+            return emitVectorObjectFieldWriteAtBase(layout, layoutMap, field);
+    }
+}
+function emitVectorObjectFieldWriteAtBase(layout, layoutMap, field) {
+    switch (field.element.kind) {
+        case "dynamic-string":
+            return [
+                `  writer.writeTextVectorAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name}, ${encodingLiteral(field.element.encoding)});`,
+            ];
+        case "dynamic-bytes":
+            return [
+                `  writer.writeBytesVectorAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name});`,
+            ];
+        case "fixed-bytes":
+            return [
+                `  writer.writeFixedBytesVectorAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name}, ${field.element.byteLength});`,
+            ];
+        case "fixed-string":
+            return [
+                `  writer.writeFixedTextVectorAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name}, ${field.element.byteLength}, ${encodingLiteral(field.element.encoding)});`,
+            ];
+        case "scalar":
+            return [
+                `  writer.writeScalarVectorAtBase(baseOffset, ${layout.name}View.${field.name}Offset, "${field.element.scalar}", value.${field.name});`,
+            ];
+        case "struct": {
+            const elementLayout = layoutMap.get(field.element.typeName);
+            const alignment = elementLayout?.alignment ?? 1;
+            return [
+                `  writer.writeStructVectorAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name}, ${field.element.byteLength}, (view, elementValue, elementBaseOffset, elementLittleEndian) => ${field.element.typeName}View.write(view, elementValue, elementBaseOffset, elementLittleEndian), ${alignment});`,
+            ];
+        }
+        case "dynamic-struct": {
+            const elementLayout = layoutMap.get(field.element.typeName);
+            const alignment = elementLayout?.alignment ?? 1;
+            const elementByteLength = elementLayout?.byteLength ?? field.element.byteLength;
+            const writeElement = elementLayout !== undefined && hasTailWriterFields(elementLayout, layoutMap)
+                ? `${field.element.typeName}View.writeInto(view, elementWriter, elementValue, elementBaseOffset, elementLittleEndian)`
+                : `${field.element.typeName}View.write(view, elementValue, elementBaseOffset, elementLittleEndian)`;
+            return [
+                `  writer.writeDynamicStructVectorAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name}, ${elementByteLength}, (view, elementWriter, elementValue, elementBaseOffset, elementLittleEndian) => ${writeElement}, ${alignment});`,
+            ];
+        }
+        case "pointer":
+            return [
+                `  writer.writePointerVectorAtBase(baseOffset, ${layout.name}View.${field.name}Offset, value.${field.name}, ${field.element.targetTypeName}View.byteLength);`,
+            ];
+    }
+}
+function emitStaticFieldAccessor(layout, field, scanKernelMode) {
     if (field.kind === "pointer") {
-        const pascalName = toPascalCase(field.name);
-        const littleEndianDefault = toLittleEndianLiteral(layout);
-        const indexOffset = `index * ${layout.byteLength} + ${field.offset}`;
-        const pointerPosition = `baseOffset + ${field.offset}`;
-        return method `
+        return emitStaticPointerAccessor(layout, field);
+    }
+    return field.kind === "scalar" ? emitStaticScalarAccessor(layout, field, scanKernelMode) : [];
+}
+function emitStaticScalarAccessor(layout, field, scanKernelMode) {
+    const getterMethod = scalarGetterMethod(field.scalar);
+    const setterMethod = scalarSetterMethod(field.scalar);
+    const typeName = scalarTsType(field.scalar);
+    const littleEndianDefault = toLittleEndianLiteral(layout);
+    const endianArg = field.byteLength === 1 || field.scalar === "bool" ? "" : ", littleEndian";
+    const indexOffset = `index * ${layout.byteLength} + ${field.offset}`;
+    const pascalName = toPascalCase(field.name);
+    return [
+        `  static get${pascalName}(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): ${typeName} {`,
+        emitStaticScalarReadBody(field, getterMethod, `baseOffset + ${field.offset}`, endianArg),
+        "  }",
+        `  static set${pascalName}(view: DataView, value: ${typeName}, baseOffset = 0, littleEndian = ${littleEndianDefault}): void {`,
+        emitStaticScalarWriteBody(field, setterMethod, `baseOffset + ${field.offset}`, endianArg),
+        "  }",
+        `  static get${pascalName}At(view: DataView, index: number, littleEndian = ${littleEndianDefault}): ${typeName} {`,
+        emitStaticScalarReadBody(field, getterMethod, indexOffset, endianArg),
+        "  }",
+        `  static set${pascalName}At(view: DataView, value: ${typeName}, index: number, littleEndian = ${littleEndianDefault}): void {`,
+        emitStaticScalarWriteBody(field, setterMethod, indexOffset, endianArg),
+        "  }",
+        ...emitScalarScanKernels(layout, field, getterMethod, littleEndianDefault, pascalName, scanKernelMode),
+    ];
+}
+function emitStaticScalarReadBody(field, getterMethod, offsetExpr, endianArg) {
+    return field.scalar === "bool"
+        ? `    return view.${getterMethod}(${offsetExpr}) !== 0;`
+        : `    return view.${getterMethod}(${offsetExpr}${endianArg});`;
+}
+function emitStaticScalarWriteBody(field, setterMethod, offsetExpr, endianArg) {
+    return field.scalar === "bool"
+        ? `    view.${setterMethod}(${offsetExpr}, value ? 1 : 0);`
+        : `    view.${setterMethod}(${offsetExpr}, value${endianArg});`;
+}
+function emitStaticPointerAccessor(layout, field) {
+    const pascalName = toPascalCase(field.name);
+    const littleEndianDefault = toLittleEndianLiteral(layout);
+    const indexOffset = `index * ${layout.byteLength} + ${field.offset}`;
+    const pointerPosition = `baseOffset + ${field.offset}`;
+    return method `
 static getRaw${pascalName}RelativeOffset(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): number {
   return view.getUint32(baseOffset + ${field.offset}, littleEndian);
 }
@@ -448,87 +479,17 @@ static set${pascalName}RelativeOffsetAt(view: DataView, value: number | null, in
   ${layout.name}View.assertPointer32Payload(value);
   view.setInt32(${indexOffset}, value, littleEndian);
 }`;
-    }
-    if (field.kind !== "scalar") {
-        return [];
-    }
-    const getterMethod = scalarGetterMethod(field.scalar);
-    const setterMethod = scalarSetterMethod(field.scalar);
-    const typeName = scalarTsType(field.scalar);
-    const littleEndianDefault = toLittleEndianLiteral(layout);
-    const endianArg = field.byteLength === 1 || field.scalar === "bool" ? "" : ", littleEndian";
-    const getterBody = field.scalar === "bool"
-        ? `    return view.${getterMethod}(baseOffset + ${field.offset}) !== 0;`
-        : `    return view.${getterMethod}(baseOffset + ${field.offset}${endianArg});`;
-    const setterBody = field.scalar === "bool"
-        ? `    view.${setterMethod}(baseOffset + ${field.offset}, value ? 1 : 0);`
-        : `    view.${setterMethod}(baseOffset + ${field.offset}, value${endianArg});`;
-    const indexOffset = `index * ${layout.byteLength} + ${field.offset}`;
-    const indexGetterBody = field.scalar === "bool"
-        ? `    return view.${getterMethod}(${indexOffset}) !== 0;`
-        : `    return view.${getterMethod}(${indexOffset}${endianArg});`;
-    const indexSetterBody = field.scalar === "bool"
-        ? `    view.${setterMethod}(${indexOffset}, value ? 1 : 0);`
-        : `    view.${setterMethod}(${indexOffset}, value${endianArg});`;
-    const pascalName = toPascalCase(field.name);
-    return [
-        `  static get${pascalName}(view: DataView, baseOffset = 0, littleEndian = ${littleEndianDefault}): ${typeName} {`,
-        getterBody,
-        "  }",
-        `  static set${pascalName}(view: DataView, value: ${typeName}, baseOffset = 0, littleEndian = ${littleEndianDefault}): void {`,
-        setterBody,
-        "  }",
-        `  static get${pascalName}At(view: DataView, index: number, littleEndian = ${littleEndianDefault}): ${typeName} {`,
-        indexGetterBody,
-        "  }",
-        `  static set${pascalName}At(view: DataView, value: ${typeName}, index: number, littleEndian = ${littleEndianDefault}): void {`,
-        indexSetterBody,
-        "  }",
-        ...emitScalarSumKernel(layout, field, getterMethod, littleEndianDefault, pascalName),
-    ];
-}
-function emitScalarSumKernel(layout, field, getterMethod, littleEndianDefault, pascalName) {
-    if (!isNumberSumScalar(field.scalar)) {
-        return [];
-    }
-    const endianArg = field.byteLength === 1 ? "" : ", littleEndian";
-    return method `
-static sum${pascalName}(view: DataView, count: number, baseOffset = 0, littleEndian = ${littleEndianDefault}): number {
-  if (!Number.isInteger(count) || count < 0) {
-    throw new RangeError(\`Invalid record count: \${count}\`);
-  }
-  if (!Number.isFinite(baseOffset) || !Number.isInteger(baseOffset) || baseOffset < 0) {
-    throw new RangeError(\`Invalid base offset: \${baseOffset}\`);
-  }
-  if (count === 0) {
-    return 0;
-  }
-  const start = baseOffset + ${field.offset};
-  const limit = start + count * ${layout.byteLength};
-  const lastByte = start + (count - 1) * ${layout.byteLength} + ${field.byteLength};
-  if (lastByte > view.byteLength) {
-    throw new RangeError(\`scan range exceeds DataView length \${view.byteLength}\`);
-  }
-  let sum = 0;
-  for (let offset = start; offset < limit; offset += ${layout.byteLength}) {
-    sum += view.${getterMethod}(offset${endianArg});
-  }
-  return sum;
-}`;
-}
-function isNumberSumScalar(kind) {
-    return kind !== "i64" && kind !== "u64" && kind !== "bool";
 }
-function emitField(layout, field, options) {
+function emitField(layout, field) {
+    // This switch intentionally mirrors the Layout IR field-kind surface.
+    // Split it only when a dispatch table removes real emitter complexity.
     switch (field.kind) {
         case "scalar": {
             const getterMethod = scalarGetterMethod(field.scalar);
             const setterMethod = scalarSetterMethod(field.scalar);
             const typeName = scalarTsType(field.scalar);
             const getterArgs = field.byteLength === 1 || field.scalar === "bool" ? "" : ", this.littleEndian";
-            const instanceOffset = options.optimizeCursorOffsets
-                ? `this.$${field.name}Offset`
-                : `this.baseOffset + ${field.offset}`;
+            const instanceOffset = `this.baseOffset + ${field.offset}`;
             const getterBody = field.scalar === "bool"
                 ? `return this.view.${getterMethod}(${instanceOffset}) !== 0;`
                 : `return this.view.${getterMethod}(${instanceOffset}${getterArgs});`;
@@ -575,8 +536,58 @@ ${field.name}View(): ${field.typeName}View {
   return new ${field.typeName}View(this.view, this.absoluteOffset(${field.offset}), this.littleEndian);
 }`;
         case "pointer": {
-            const pascalName = toPascalCase(field.name);
-            return method `
+            return emitPointerField(layout, field);
+        }
+        case "fixed-array":
+            return emitFixedArrayFieldAccessor(field, encodingLiteral);
+        case "vector":
+            switch (field.element.kind) {
+                case "scalar":
+                    return method `
+${field.name}View(): ScalarVectorView<${scalarTsType(field.element.scalar)}> {
+  return new ScalarVectorView(this.view, ${field.offset}, "${field.element.scalar}", this.baseOffset, this.littleEndian);
+}`;
+                case "dynamic-string":
+                    return method `
+${field.name}View(): Utf8VectorView {
+  return new Utf8VectorView(this.view, ${field.offset}, this.baseOffset, this.littleEndian, ${encodingLiteral(field.element.encoding)});
+}`;
+                case "dynamic-bytes":
+                    return method `
+${field.name}View(): BytesVectorView {
+  return new BytesVectorView(this.view, ${field.offset}, this.baseOffset, this.littleEndian);
+}`;
+                case "fixed-bytes":
+                    return method `
+${field.name}View(): FixedBytesVectorView {
+  return new FixedBytesVectorView(this.view, ${field.offset}, ${field.element.byteLength}, this.baseOffset, this.littleEndian);
+}`;
+                case "fixed-string":
+                    return method `
+${field.name}View(): FixedStringVectorView {
+  return new FixedStringVectorView(this.view, ${field.offset}, ${field.element.byteLength}, this.baseOffset, this.littleEndian, ${encodingLiteral(field.element.encoding)});
+}`;
+                case "struct":
+                    return method `
+${field.name}View(): StructVectorView<${field.element.typeName}View> {
+  return new StructVectorView(this.view, ${field.offset}, ${field.element.byteLength}, (view, baseOffset, littleEndian) => new ${field.element.typeName}View(view, baseOffset, littleEndian), this.baseOffset, this.littleEndian);
+}`;
+                case "dynamic-struct":
+                    return method `
+${field.name}View(): DynamicStructVectorView<${field.element.typeName}View> {
+  return new DynamicStructVectorView(this.view, ${field.offset}, (view, baseOffset, littleEndian) => new ${field.element.typeName}View(view, baseOffset, littleEndian), this.baseOffset, this.littleEndian);
+}`;
+                case "pointer":
+                    return method `
+${field.name}View(): PointerVectorView<${field.element.targetTypeName}View> {
+  return new PointerVectorView(this.view, ${field.offset}, ${field.element.targetTypeName}View.byteLength, (view, baseOffset, littleEndian) => new ${field.element.targetTypeName}View(view, baseOffset, littleEndian), this.baseOffset, this.littleEndian);
+}`;
+            }
+    }
+}
+function emitPointerField(layout, field) {
+    const pascalName = toPascalCase(field.name);
+    return method `
 get raw${pascalName}RelativeOffset(): number {
   return this.view.getUint32(this.baseOffset + ${field.offset}, this.littleEndian);
 }
@@ -643,104 +654,5 @@ ${field.name}Into(out: ${field.targetTypeName}View): boolean {
   out.moveToOffset(targetOffset, ${field.targetTypeName}View.byteLength);
   return true;
 }`;
-        }
-        case "fixed-array":
-            return emitFixedArrayFieldAccessor(field, encodingLiteral);
-        case "vector":
-            switch (field.element.kind) {
-                case "scalar":
-                    return method `
-${field.name}View(): ScalarVectorView<${scalarTsType(field.element.scalar)}> {
-  return new ScalarVectorView(this.view, ${field.offset}, "${field.element.scalar}", this.baseOffset, this.littleEndian);
-}`;
-                case "dynamic-string":
-                    return method `
-${field.name}View(): Utf8VectorView {
-  return new Utf8VectorView(this.view, ${field.offset}, this.baseOffset, this.littleEndian, ${encodingLiteral(field.element.encoding)});
-}`;
-                case "dynamic-bytes":
-                    return method `
-${field.name}View(): BytesVectorView {
-  return new BytesVectorView(this.view, ${field.offset}, this.baseOffset, this.littleEndian);
-}`;
-                case "fixed-bytes":
-                    return method `
-${field.name}View(): FixedBytesVectorView {
-  return new FixedBytesVectorView(this.view, ${field.offset}, ${field.element.byteLength}, this.baseOffset, this.littleEndian);
-}`;
-                case "fixed-string":
-                    return method `
-${field.name}View(): FixedStringVectorView {
-  return new FixedStringVectorView(this.view, ${field.offset}, ${field.element.byteLength}, this.baseOffset, this.littleEndian, ${encodingLiteral(field.element.encoding)});
-}`;
-                case "struct":
-                    return method `
-${field.name}View(): StructVectorView<${field.element.typeName}View> {
-  return new StructVectorView(this.view, ${field.offset}, ${field.element.byteLength}, (view, baseOffset, littleEndian) => new ${field.element.typeName}View(view, baseOffset, littleEndian), this.baseOffset, this.littleEndian);
-}`;
-                case "pointer":
-                    return method `
-${field.name}View(): PointerVectorView<${field.element.targetTypeName}View> {
-  return new PointerVectorView(this.view, ${field.offset}, ${field.element.targetTypeName}View.byteLength, (view, baseOffset, littleEndian) => new ${field.element.targetTypeName}View(view, baseOffset, littleEndian), this.baseOffset, this.littleEndian);
-}`;
-            }
-    }
-}
-function toPascalCase(name) {
-    return name.slice(0, 1).toUpperCase() + name.slice(1);
-}
-function toLittleEndianLiteral(layout) {
-    return layout.endianness === "little" ? "true" : "false";
-}
-function encodingLiteral(encoding) {
-    return encoding === "ascii" ? "\"ascii\"" : "\"utf8\"";
-}
-function hasTailWriterFields(layout, layoutMap) {
-    return layout.fields.some((field) => isTailWriterField(field, layoutMap));
-}
-function isTailWriterField(field, layoutMap) {
-    switch (field.kind) {
-        case "dynamic-string":
-        case "dynamic-bytes":
-            return true;
-        case "vector":
-            return (field.element.kind === "scalar" ||
-                field.element.kind === "fixed-bytes" ||
-                field.element.kind === "fixed-string" ||
-                field.element.kind === "dynamic-string" ||
-                field.element.kind === "dynamic-bytes" ||
-                field.element.kind === "pointer" ||
-                canWriteStructVectorElement(field.element, layoutMap));
-        default:
-            return false;
-    }
-}
-function canEmitObjectWriter(layout, layoutMap) {
-    return layout.fields.every((field) => canWriteObjectField(field, layoutMap));
-}
-function canWriteObjectField(field, layoutMap) {
-    switch (field.kind) {
-        case "scalar":
-        case "fixed-bytes":
-        case "fixed-string":
-        case "dynamic-string":
-        case "dynamic-bytes":
-        case "struct":
-        case "pointer":
-            return true;
-        case "fixed-array":
-            return (field.element.kind !== "struct" ||
-                canWriteFixedArrayStructElement(field.element, layoutMap, hasTailWriterFields));
-        case "vector":
-            return (field.element.kind !== "struct" ||
-                canWriteStructVectorElement(field.element, layoutMap));
-    }
-}
-function canWriteStructVectorElement(element, layoutMap) {
-    if (element.kind !== "struct") {
-        return false;
-    }
-    const elementLayout = layoutMap.get(element.typeName);
-    return elementLayout !== undefined && !hasTailWriterFields(elementLayout, layoutMap);
 }
 //# sourceMappingURL=emitter.js.map