@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/frontend/derive_macros.js

@@ -0,0 +1,2072 @@
+import ts from 'typescript';
+import { createAnnotationLookup } from '../annotation_syntax.js';
+import { fromFileUrl } from '../platform/path.js';
+import { macroSignature } from './macro_api.js';
+import { attachMacroFactoryMetadata } from './macro_api_internal.js';
+import { getHostDeclaration } from './macro_syntax_internal.js';
+const DERIVE_MACRO_FILE_NAME = fromFileUrl(import.meta.url);
+const DERIVE_SIGNATURE = macroSignature.oneOf(macroSignature.case('class', macroSignature.classDecl('target')), macroSignature.case('interface', macroSignature.interfaceDecl('target')), macroSignature.case('typeAlias', macroSignature.typeAliasDecl('target')));
+const DECODE_SIGNATURE = macroSignature.oneOf(macroSignature.case('class', macroSignature.classDecl('target')), macroSignature.case('interface', macroSignature.interfaceDecl('target')), macroSignature.case('typeAlias', macroSignature.typeAliasDecl('target')));
+const TAGGED_SIGNATURE = macroSignature.of(macroSignature.typeAliasDecl('target'));
+const CLASS_DECODE_VALUE_PLACEHOLDER = '__sts_decoded_value__';
+function attachDeriveFactory(factory) {
+    return attachMacroFactoryMetadata(factory, {
+        form: 'decl',
+        moduleFileName: DERIVE_MACRO_FILE_NAME,
+    });
+}
+function findAnnotation(annotations, name) {
+    return annotations.find((annotation) => annotation.name === name) ?? null;
+}
+function annotationIdentifierArgument(annotation) {
+    const [firstArgument] = annotation.arguments ?? [];
+    return firstArgument?.value.kind === 'identifier' ? firstArgument.value.name : null;
+}
+function annotationStringArgument(annotation) {
+    const [firstArgument] = annotation.arguments ?? [];
+    return firstArgument?.value.kind === 'string' ? firstArgument.value.value : null;
+}
+function annotationDiagnosticNode(declaration, annotation) {
+    const hostDeclaration = getHostDeclaration(declaration);
+    const sourceFile = hostDeclaration.getSourceFile();
+    const parsedAnnotation = createAnnotationLookup(sourceFile)
+        .getAttachedAnnotations(hostDeclaration)
+        .find((attached) => attached.name === annotation.name && attached.text === annotation.text);
+    if (!parsedAnnotation?.range) {
+        return null;
+    }
+    return {
+        kind: 'annotation',
+        span: {
+            fileName: sourceFile.fileName,
+            start: parsedAnnotation.range.start,
+            end: parsedAnnotation.range.end,
+        },
+    };
+}
+function propertyAccessText(receiverName, propertyName) {
+    const receiver = /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(receiverName.trim())
+        ? receiverName.trim()
+        : `(${receiverName.trim()})`;
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(propertyName)
+        ? `${receiver}.${propertyName}`
+        : `${receiver}[${JSON.stringify(propertyName)}]`;
+}
+function propertyKeyText(propertyName) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(propertyName)
+        ? propertyName
+        : JSON.stringify(propertyName);
+}
+function primitiveKindForTypeText(typeText) {
+    const normalized = typeText.trim();
+    switch (normalized) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+            return normalized;
+        default:
+            return null;
+    }
+}
+function parseGenericTypeArgument(text, typeName) {
+    const parsed = parseGenericTypeArguments(text, typeName);
+    return parsed?.length === 1 ? parsed[0] : null;
+}
+function parseGenericTypeArguments(text, typeName) {
+    const trimmed = text.trim();
+    const prefix = `${typeName}<`;
+    if (!trimmed.startsWith(prefix) || !trimmed.endsWith('>')) {
+        return null;
+    }
+    let angleDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    let inString = null;
+    let escaped = false;
+    let segmentStart = prefix.length;
+    const args = [];
+    for (let index = typeName.length; index < trimmed.length; index += 1) {
+        const char = trimmed[index];
+        if (inString !== null) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === inString) {
+                inString = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            inString = char;
+            continue;
+        }
+        switch (char) {
+            case '<':
+                angleDepth += 1;
+                continue;
+            case '>':
+                angleDepth -= 1;
+                if (angleDepth < 0) {
+                    return null;
+                }
+                if (angleDepth === 0) {
+                    if (index !== trimmed.length - 1) {
+                        return null;
+                    }
+                    const segment = trimmed.slice(segmentStart, index).trim();
+                    if (segment.length === 0) {
+                        return null;
+                    }
+                    args.push(segment);
+                }
+                continue;
+            case '{':
+                braceDepth += 1;
+                continue;
+            case '}':
+                braceDepth -= 1;
+                if (braceDepth < 0) {
+                    return null;
+                }
+                continue;
+            case '[':
+                bracketDepth += 1;
+                continue;
+            case ']':
+                bracketDepth -= 1;
+                if (bracketDepth < 0) {
+                    return null;
+                }
+                continue;
+            case '(':
+                parenDepth += 1;
+                continue;
+            case ')':
+                parenDepth -= 1;
+                if (parenDepth < 0) {
+                    return null;
+                }
+                continue;
+            case ',':
+                if (angleDepth === 1 && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+                    const segment = trimmed.slice(segmentStart, index).trim();
+                    if (segment.length === 0) {
+                        return null;
+                    }
+                    args.push(segment);
+                    segmentStart = index + 1;
+                }
+                continue;
+            default:
+                continue;
+        }
+    }
+    if (angleDepth !== 0 || braceDepth !== 0 || bracketDepth !== 0 || parenDepth !== 0 ||
+        inString !== null) {
+        return null;
+    }
+    return args;
+}
+function parseArrayInnerTypeText(typeText) {
+    const trimmed = typeText.trim();
+    if (trimmed.startsWith('readonly ') && trimmed.endsWith('[]')) {
+        return trimmed.slice('readonly '.length, -2).trim();
+    }
+    if (trimmed.endsWith('[]')) {
+        return trimmed.slice(0, -2).trim();
+    }
+    return parseGenericTypeArgument(trimmed, 'Array') ??
+        parseGenericTypeArgument(trimmed, 'ReadonlyArray');
+}
+function parseTupleElementTypeTexts(typeText) {
+    const trimmed = typeText.trim();
+    const tupleText = trimmed.startsWith('readonly [') ? trimmed.slice('readonly '.length) : trimmed;
+    if (!tupleText.startsWith('[') || !tupleText.endsWith(']')) {
+        return null;
+    }
+    const body = tupleText.slice(1, -1).trim();
+    if (body.length === 0) {
+        return [];
+    }
+    let angleDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    let inString = null;
+    let escaped = false;
+    let segmentStart = 0;
+    const elements = [];
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        if (inString !== null) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === inString) {
+                inString = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            inString = char;
+            continue;
+        }
+        switch (char) {
+            case '<':
+                angleDepth += 1;
+                continue;
+            case '>':
+                angleDepth -= 1;
+                if (angleDepth < 0) {
+                    return null;
+                }
+                continue;
+            case '{':
+                braceDepth += 1;
+                continue;
+            case '}':
+                braceDepth -= 1;
+                if (braceDepth < 0) {
+                    return null;
+                }
+                continue;
+            case '[':
+                bracketDepth += 1;
+                continue;
+            case ']':
+                bracketDepth -= 1;
+                if (bracketDepth < 0) {
+                    return null;
+                }
+                continue;
+            case '(':
+                parenDepth += 1;
+                continue;
+            case ')':
+                parenDepth -= 1;
+                if (parenDepth < 0) {
+                    return null;
+                }
+                continue;
+            case ',':
+                if (angleDepth === 0 && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+                    const segment = body.slice(segmentStart, index).trim();
+                    if (segment.length === 0) {
+                        return null;
+                    }
+                    elements.push(segment);
+                    segmentStart = index + 1;
+                }
+                continue;
+            default:
+                continue;
+        }
+    }
+    if (angleDepth !== 0 || braceDepth !== 0 || bracketDepth !== 0 || parenDepth !== 0 ||
+        inString !== null) {
+        return null;
+    }
+    const finalSegment = body.slice(segmentStart).trim();
+    if (finalSegment.length === 0) {
+        return null;
+    }
+    elements.push(finalSegment);
+    return elements;
+}
+function parseSupportedDerivedType(typeText) {
+    const primitiveKind = primitiveKindForTypeText(typeText);
+    if (primitiveKind) {
+        return { kind: 'primitive', primitiveKind };
+    }
+    const arrayInner = parseArrayInnerTypeText(typeText);
+    if (arrayInner !== null) {
+        const element = parseSupportedDerivedType(arrayInner);
+        return element ? { kind: 'array', element } : null;
+    }
+    const tupleElements = parseTupleElementTypeTexts(typeText);
+    if (tupleElements !== null) {
+        const elements = tupleElements.map((element) => parseSupportedDerivedType(element));
+        return elements.every((element) => element !== null)
+            ? { kind: 'tuple', elements: elements }
+            : null;
+    }
+    const optionInner = parseGenericTypeArgument(typeText, 'Option');
+    if (optionInner !== null) {
+        const value = parseSupportedDerivedType(optionInner);
+        return value ? { kind: 'option', value } : null;
+    }
+    const resultArgs = parseGenericTypeArguments(typeText, 'Result');
+    if (resultArgs?.length === 2) {
+        const okType = parseSupportedDerivedType(resultArgs[0]);
+        const errType = parseSupportedDerivedType(resultArgs[1]);
+        return okType && errType ? { kind: 'result', ok: okType, err: errType } : null;
+    }
+    const trimmed = typeText.trim();
+    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(trimmed)) {
+        return { kind: 'named', typeName: trimmed };
+    }
+    return null;
+}
+function supportedDerivedTypeFromShape(shape) {
+    switch (shape.kind) {
+        case 'primitive':
+            return {
+                kind: 'primitive',
+                primitiveKind: shape.primitiveKind,
+            };
+        case 'named':
+            return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(shape.name)
+                ? { kind: 'named', typeName: shape.name }
+                : null;
+        case 'array': {
+            const element = supportedDerivedTypeFromShape(shape.element);
+            return element ? { kind: 'array', element } : null;
+        }
+        case 'tuple': {
+            const elements = shape.elements.map((element) => supportedDerivedTypeFromShape(element));
+            return elements.every((element) => element !== null)
+                ? { kind: 'tuple', elements: elements }
+                : null;
+        }
+        case 'option': {
+            const value = supportedDerivedTypeFromShape(shape.value);
+            return value ? { kind: 'option', value } : null;
+        }
+        case 'result': {
+            const ok = supportedDerivedTypeFromShape(shape.ok);
+            const err = supportedDerivedTypeFromShape(shape.err);
+            return ok && err ? { kind: 'result', ok, err } : null;
+        }
+        case 'object':
+        case 'literal':
+        case 'union':
+        case 'unsupported':
+            return null;
+    }
+}
+function objectLikeDeclarationShape(ctx, declaration, macroName) {
+    const shape = ctx.reflect.declarationShape(declaration);
+    if (shape.kind === 'objectLike') {
+        return shape;
+    }
+    ctx.error(`${macroName} currently only supports object-like declarations in v1.`, declaration);
+}
+function discriminatedUnionDeclarationShape(ctx, declaration, macroName) {
+    const shape = ctx.reflect.declarationShape(declaration);
+    if (shape.kind === 'discriminatedUnion') {
+        return shape;
+    }
+    ctx.error(`${macroName} only supports // #[tagged] unions of object-like variants in v1.`, declaration);
+}
+function eqHashUnsupportedFieldMessage(macroName) {
+    return `${macroName} only supports fields with explicit primitive, nested object literal, tuple, array, Option/Result, or named derived types in v1. Add // #[${macroName}.via(...)] or // #[${macroName}.skip].`;
+}
+function decodeLikeUnsupportedFieldMessage(macroName) {
+    switch (macroName) {
+        case 'decode':
+            return 'decode only supports fields with explicit primitive, nested object literal, tuple, array, Option/Result, or named derived types in v1. Add // #[decode.via(...)] to supply a custom decoder.';
+        case 'encode':
+            return 'encode only supports fields with explicit primitive, nested object literal, tuple, array, Option/Result, or named derived types in v1. Add // #[encode.via(...)] to supply a custom encoder.';
+        case 'codec':
+            return 'codec only supports fields with explicit primitive, nested object literal, tuple, array, Option/Result, or named derived types in v1. Add // #[codec.via(...)] to supply a custom codec.';
+    }
+}
+function compareHelperName(kind) {
+    switch (kind) {
+        case 'string':
+            return 'stringEq';
+        case 'number':
+            return 'numberEq';
+        case 'boolean':
+            return 'booleanEq';
+        case 'bigint':
+            return 'bigintEq';
+    }
+}
+function hashHelperName(kind) {
+    switch (kind) {
+        case 'string':
+            return 'stringHash';
+        case 'number':
+            return 'numberHash';
+        case 'boolean':
+            return 'booleanHash';
+        case 'bigint':
+            return 'bigintHash';
+    }
+}
+function decodeHelperName(kind) {
+    switch (kind) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'bigint':
+            return 'bigint';
+    }
+}
+function encodeHelperName(kind) {
+    switch (kind) {
+        case 'string':
+            return 'stringEncoder';
+        case 'number':
+            return 'numberEncoder';
+        case 'boolean':
+            return 'booleanEncoder';
+        case 'bigint':
+            return 'bigintEncoder';
+    }
+}
+function eqHelperTextForType(ctx, type) {
+    switch (type.kind) {
+        case 'primitive':
+            return ctx.runtime.named('sts:compare', compareHelperName(type.primitiveKind)).text();
+        case 'named':
+            return `${ctx.runtime.named('sts:compare', 'lazyEq').text()}(() => ${type.typeName}Eq)`;
+        case 'array':
+            return `${ctx.runtime.named('sts:compare', 'arrayEq').text()}(${eqHelperTextForType(ctx, type.element)})`;
+        case 'tuple':
+            return `${ctx.runtime.named('sts:compare', 'tupleEq').text()}(${type.elements.map((element) => eqHelperTextForType(ctx, element)).join(', ')})`;
+        case 'option':
+            return `${ctx.runtime.named('sts:compare', 'optionEq').text()}(${eqHelperTextForType(ctx, type.value)})`;
+        case 'result':
+            return `${ctx.runtime.named('sts:compare', 'resultEq').text()}(${eqHelperTextForType(ctx, type.ok)}, ${eqHelperTextForType(ctx, type.err)})`;
+    }
+}
+function hashHelperTextForType(ctx, type) {
+    switch (type.kind) {
+        case 'primitive':
+            return ctx.runtime.named('sts:hash', hashHelperName(type.primitiveKind)).text();
+        case 'named':
+            return `${ctx.runtime.named('sts:hash', 'lazyHashEq').text()}(() => ${type.typeName}Hash)`;
+        case 'array':
+            return `${ctx.runtime.named('sts:hash', 'arrayHash').text()}(${hashHelperTextForType(ctx, type.element)})`;
+        case 'tuple':
+            return `${ctx.runtime.named('sts:hash', 'tupleHash').text()}(${type.elements.map((element) => hashHelperTextForType(ctx, element)).join(', ')})`;
+        case 'option':
+            return `${ctx.runtime.named('sts:hash', 'optionHash').text()}(${hashHelperTextForType(ctx, type.value)})`;
+        case 'result':
+            return `${ctx.runtime.named('sts:hash', 'resultHash').text()}(${hashHelperTextForType(ctx, type.ok)}, ${hashHelperTextForType(ctx, type.err)})`;
+    }
+}
+function decodeHelperTextForType(ctx, type) {
+    switch (type.kind) {
+        case 'primitive':
+            return ctx.runtime.named('sts:decode', decodeHelperName(type.primitiveKind)).text();
+        case 'named':
+            return `${ctx.runtime.named('sts:decode', 'lazy').text()}(() => ${type.typeName}Decoder)`;
+        case 'array':
+            return `${ctx.runtime.named('sts:decode', 'array').text()}(${decodeHelperTextForType(ctx, type.element)})`;
+        case 'tuple':
+            return `${ctx.runtime.named('sts:decode', 'tuple').text()}(${type.elements.map((element) => decodeHelperTextForType(ctx, element)).join(', ')})`;
+        case 'option':
+            return `${ctx.runtime.named('sts:decode', 'option').text()}(${decodeHelperTextForType(ctx, type.value)})`;
+        case 'result':
+            return `${ctx.runtime.named('sts:decode', 'result').text()}(${decodeHelperTextForType(ctx, type.ok)}, ${decodeHelperTextForType(ctx, type.err)})`;
+    }
+}
+function encodeHelperTextForType(ctx, type) {
+    switch (type.kind) {
+        case 'primitive':
+            return ctx.runtime.named('sts:encode', encodeHelperName(type.primitiveKind)).text();
+        case 'named':
+            return `${ctx.runtime.named('sts:encode', 'lazy').text()}(() => ${type.typeName}Encoder)`;
+        case 'array':
+            return `${ctx.runtime.named('sts:encode', 'array').text()}(${encodeHelperTextForType(ctx, type.element)})`;
+        case 'tuple':
+            return `${ctx.runtime.named('sts:encode', 'tuple').text()}(${type.elements.map((element) => encodeHelperTextForType(ctx, element)).join(', ')})`;
+        case 'option':
+            return `${ctx.runtime.named('sts:encode', 'option').text()}(${encodeHelperTextForType(ctx, type.value)})`;
+        case 'result':
+            return `${ctx.runtime.named('sts:encode', 'result').text()}(${encodeHelperTextForType(ctx, type.ok)}, ${encodeHelperTextForType(ctx, type.err)})`;
+    }
+}
+function codecHelperTextsForType(ctx, type) {
+    switch (type.kind) {
+        case 'primitive':
+            return {
+                decodeText: ctx.runtime.named('sts:decode', decodeHelperName(type.primitiveKind)).text(),
+                encodeText: ctx.runtime.named('sts:encode', encodeHelperName(type.primitiveKind)).text(),
+            };
+        case 'named':
+            return {
+                decodeText: `${ctx.runtime.named('sts:decode', 'lazy').text()}(() => ${type.typeName}Codec)`,
+                encodeText: `${ctx.runtime.named('sts:encode', 'lazy').text()}(() => ${type.typeName}Codec)`,
+            };
+        case 'array': {
+            const element = codecHelperTextsForType(ctx, type.element);
+            return {
+                decodeText: `${ctx.runtime.named('sts:decode', 'array').text()}(${element.decodeText})`,
+                encodeText: `${ctx.runtime.named('sts:encode', 'array').text()}(${element.encodeText})`,
+            };
+        }
+        case 'tuple':
+            return {
+                decodeText: `${ctx.runtime.named('sts:decode', 'tuple').text()}(${type.elements.map((element) => codecHelperTextsForType(ctx, element).decodeText).join(', ')})`,
+                encodeText: `${ctx.runtime.named('sts:encode', 'tuple').text()}(${type.elements.map((element) => codecHelperTextsForType(ctx, element).encodeText).join(', ')})`,
+            };
+        case 'option': {
+            const value = codecHelperTextsForType(ctx, type.value);
+            return {
+                decodeText: `${ctx.runtime.named('sts:decode', 'option').text()}(${value.decodeText})`,
+                encodeText: `${ctx.runtime.named('sts:encode', 'option').text()}(${value.encodeText})`,
+            };
+        }
+        case 'result': {
+            const okType = codecHelperTextsForType(ctx, type.ok);
+            const errType = codecHelperTextsForType(ctx, type.err);
+            return {
+                decodeText: `${ctx.runtime.named('sts:decode', 'result').text()}(${okType.decodeText}, ${errType.decodeText})`,
+                encodeText: `${ctx.runtime.named('sts:encode', 'result').text()}(${okType.encodeText}, ${errType.encodeText})`,
+            };
+        }
+    }
+}
+function expectedCompanionName(typeName, macroName) {
+    switch (macroName) {
+        case 'eq':
+            return `${typeName}Eq`;
+        case 'hash':
+            return `${typeName}Hash`;
+        case 'decode':
+            return `${typeName}Decoder`;
+        case 'encode':
+            return `${typeName}Encoder`;
+        case 'codec':
+            return `${typeName}Codec`;
+    }
+}
+function missingNamedDerivedCompanionMessage(macroName, companionName) {
+    switch (macroName) {
+        case 'eq':
+        case 'hash':
+            return `${macroName} requires the companion value "${companionName}" to be in scope for named derived types. Add an import or use // #[${macroName}.via(...)] or // #[${macroName}.skip].`;
+        case 'decode':
+            return `decode requires the companion value "${companionName}" to be in scope for named derived types. Add an import or use // #[decode.via(...)] to supply a custom decoder.`;
+        case 'encode':
+            return `encode requires the companion value "${companionName}" to be in scope for named derived types. Add an import or use // #[encode.via(...)] to supply a custom encoder.`;
+        case 'codec':
+            return `codec requires the companion value "${companionName}" to be in scope for named derived types. Add an import or use // #[codec.via(...)] to supply a custom codec.`;
+    }
+}
+function assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, errorNode, type) {
+    switch (type.kind) {
+        case 'primitive':
+            return;
+        case 'array':
+            assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, errorNode, type.element);
+            return;
+        case 'tuple':
+            for (const element of type.elements) {
+                assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, errorNode, element);
+            }
+            return;
+        case 'option':
+            assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, errorNode, type.value);
+            return;
+        case 'result':
+            assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, errorNode, type.ok);
+            assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, errorNode, type.err);
+            return;
+        case 'named': {
+            if (type.typeName === ownerTypeName) {
+                return;
+            }
+            const companionName = expectedCompanionName(type.typeName, macroName);
+            if (!ctx.semantics.valueBindingInScope(companionName) &&
+                !ctx.semantics.localDeclarationHasAnnotation(type.typeName, macroName)) {
+                ctx.error(missingNamedDerivedCompanionMessage(macroName, companionName), errorNode);
+            }
+            return;
+        }
+    }
+}
+function eqHashFieldFromReflectedShape(ctx, field, macroName, ownerTypeName, scopeNode) {
+    const annotations = field.annotations;
+    if (findAnnotation(annotations, `${macroName}.skip`)) {
+        return null;
+    }
+    const viaAnnotation = findAnnotation(annotations, `${macroName}.via`);
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error(`${macroName}.via(...) requires a helper identifier.`, field.node);
+    }
+    if (viaIdentifier) {
+        return {
+            eqHelper: viaIdentifier,
+            hashHelper: viaIdentifier,
+            name: field.name,
+            optional: field.optional,
+        };
+    }
+    if (!field.type) {
+        ctx.error(eqHashUnsupportedFieldMessage(macroName), field.node);
+    }
+    if (field.type.kind === 'object') {
+        return {
+            eqHelper: macroName === 'eq'
+                ? nestedEqHelperTextFromFields(ctx, ownerTypeName, scopeNode, field.type.fields)
+                : nestedHashHelperTextFromFields(ctx, ownerTypeName, scopeNode, field.type.fields),
+            hashHelper: nestedHashHelperTextFromFields(ctx, ownerTypeName, scopeNode, field.type.fields),
+            name: field.name,
+            optional: field.optional,
+        };
+    }
+    const fieldType = supportedDerivedTypeFromShape(field.type);
+    if (!fieldType) {
+        ctx.error(eqHashUnsupportedFieldMessage(macroName), field.node);
+    }
+    assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, field.node, fieldType);
+    return {
+        eqHelper: macroName === 'eq'
+            ? eqHelperTextForType(ctx, fieldType)
+            : hashHelperTextForType(ctx, fieldType),
+        hashHelper: hashHelperTextForType(ctx, fieldType),
+        name: field.name,
+        optional: field.optional,
+    };
+}
+function decodeFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode) {
+    const viaAnnotation = findAnnotation(field.annotations, 'decode.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('decode.via(...) requires a helper identifier.', field.node);
+    }
+    const renameAnnotation = findAnnotation(field.annotations, 'decode.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('decode.rename(...) requires a string field name.', field.node);
+    }
+    if (!field.type) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('decode'), field.node);
+    }
+    const decoderText = (() => {
+        if (viaIdentifier) {
+            return viaIdentifier;
+        }
+        if (field.type.kind === 'object') {
+            return nestedDecodeHelperTextFromFields(ctx, ownerTypeName, scopeNode, field.type.fields);
+        }
+        const fieldType = supportedDerivedTypeFromShape(field.type);
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('decode'), field.node);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'decode', ownerTypeName, scopeNode, field.node, fieldType);
+        return decodeHelperTextForType(ctx, fieldType);
+    })();
+    return {
+        decoderText,
+        localName: field.name,
+        optional: field.optional,
+        wireName: renamedWireName ?? field.name,
+    };
+}
+function encodeFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode) {
+    const viaAnnotation = findAnnotation(field.annotations, 'encode.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('encode.via(...) requires a helper identifier.', field.node);
+    }
+    const renameAnnotation = findAnnotation(field.annotations, 'encode.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('encode.rename(...) requires a string field name.', field.node);
+    }
+    if (!field.type) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('encode'), field.node);
+    }
+    const encoderText = (() => {
+        if (viaIdentifier) {
+            return viaIdentifier;
+        }
+        if (field.type.kind === 'object') {
+            return nestedEncodeHelperTextFromFields(ctx, ownerTypeName, scopeNode, field.type.fields);
+        }
+        const fieldType = supportedDerivedTypeFromShape(field.type);
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('encode'), field.node);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'encode', ownerTypeName, scopeNode, field.node, fieldType);
+        return encodeHelperTextForType(ctx, fieldType);
+    })();
+    return {
+        encoderText,
+        localName: field.name,
+        optional: field.optional,
+        wireName: renamedWireName ?? field.name,
+    };
+}
+function codecFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode) {
+    const viaAnnotation = findAnnotation(field.annotations, 'codec.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('codec.via(...) requires a helper identifier.', field.node);
+    }
+    const renameAnnotation = findAnnotation(field.annotations, 'codec.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('codec.rename(...) requires a string field name.', field.node);
+    }
+    if (!field.type) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('codec'), field.node);
+    }
+    const helperTexts = (() => {
+        if (viaIdentifier) {
+            return { decodeText: viaIdentifier, encodeText: viaIdentifier };
+        }
+        if (field.type.kind === 'object') {
+            return nestedCodecHelperTextsFromFields(ctx, ownerTypeName, scopeNode, field.type.fields);
+        }
+        const fieldType = supportedDerivedTypeFromShape(field.type);
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('codec'), field.node);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'codec', ownerTypeName, scopeNode, field.node, fieldType);
+        return codecHelperTextsForType(ctx, fieldType);
+    })();
+    return {
+        decodeText: helperTexts.decodeText,
+        encodeText: helperTexts.encodeText,
+        localName: field.name,
+        optional: field.optional,
+        wireName: renamedWireName ?? field.name,
+    };
+}
+function fieldFromObjectMember(ctx, member, macroName, ownerTypeName, scopeNode) {
+    if (member.memberKind !== 'property_signature' || member.name === null) {
+        ctx.error(`${macroName} only supports property-style object members in v1.`, member);
+    }
+    const annotations = ctx.syntax.annotations(member);
+    if (findAnnotation(annotations, `${macroName}.skip`)) {
+        return null;
+    }
+    const viaAnnotation = findAnnotation(annotations, `${macroName}.via`);
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error(`${macroName}.via(...) requires a helper identifier.`, member);
+    }
+    const explicitType = member.explicitType();
+    if (!explicitType) {
+        ctx.error(eqHashUnsupportedFieldMessage(macroName), member);
+    }
+    if (viaIdentifier) {
+        return {
+            eqHelper: viaIdentifier,
+            hashHelper: viaIdentifier,
+            name: member.name,
+            optional: member.isOptional(),
+        };
+    }
+    const objectType = explicitType.asObjectLiteral();
+    if (objectType) {
+        return {
+            eqHelper: macroName === 'eq'
+                ? nestedEqHelperText(ctx, ownerTypeName, scopeNode, objectType)
+                : nestedHashHelperText(ctx, ownerTypeName, scopeNode, objectType),
+            hashHelper: nestedHashHelperText(ctx, ownerTypeName, scopeNode, objectType),
+            name: member.name,
+            optional: member.isOptional(),
+        };
+    }
+    const fieldType = parseSupportedDerivedType(explicitType.text());
+    if (!fieldType) {
+        ctx.error(eqHashUnsupportedFieldMessage(macroName), member);
+    }
+    assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, member, fieldType);
+    return {
+        eqHelper: macroName === 'eq'
+            ? eqHelperTextForType(ctx, fieldType)
+            : hashHelperTextForType(ctx, fieldType),
+        hashHelper: hashHelperTextForType(ctx, fieldType),
+        name: member.name,
+        optional: member.isOptional(),
+    };
+}
+function fieldFromClassMember(ctx, field, macroName, ownerTypeName, scopeNode) {
+    if (field.hasModifier('private') || field.hasModifier('protected') || field.hasModifier('static') ||
+        field.name === null) {
+        return null;
+    }
+    const annotations = ctx.syntax.annotations(field);
+    if (findAnnotation(annotations, `${macroName}.skip`)) {
+        return null;
+    }
+    const viaAnnotation = findAnnotation(annotations, `${macroName}.via`);
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error(`${macroName}.via(...) requires a helper identifier.`, field);
+    }
+    const explicitType = field.explicitType();
+    if (!explicitType) {
+        ctx.error(eqHashUnsupportedFieldMessage(macroName), field);
+    }
+    if (viaIdentifier) {
+        return {
+            eqHelper: viaIdentifier,
+            hashHelper: viaIdentifier,
+            name: field.name,
+            optional: field.isOptional(),
+        };
+    }
+    const objectType = explicitType.asObjectLiteral();
+    if (objectType) {
+        return {
+            eqHelper: macroName === 'eq'
+                ? nestedEqHelperText(ctx, ownerTypeName, scopeNode, objectType)
+                : nestedHashHelperText(ctx, ownerTypeName, scopeNode, objectType),
+            hashHelper: nestedHashHelperText(ctx, ownerTypeName, scopeNode, objectType),
+            name: field.name,
+            optional: field.isOptional(),
+        };
+    }
+    const fieldType = parseSupportedDerivedType(explicitType.text());
+    if (!fieldType) {
+        ctx.error(eqHashUnsupportedFieldMessage(macroName), field);
+    }
+    assertNamedDerivedCompanionsInScope(ctx, macroName, ownerTypeName, scopeNode, field, fieldType);
+    return {
+        eqHelper: macroName === 'eq'
+            ? eqHelperTextForType(ctx, fieldType)
+            : hashHelperTextForType(ctx, fieldType),
+        hashHelper: hashHelperTextForType(ctx, fieldType),
+        name: field.name,
+        optional: field.isOptional(),
+    };
+}
+function collectFields(ctx, macroName, decoded) {
+    const declaration = decoded.args.target;
+    const shape = objectLikeDeclarationShape(ctx, declaration, macroName);
+    const typeName = shape.name ??
+        ctx.error(`${macroName} currently requires named ${shape.declarationKind} declarations.`, declaration);
+    const fields = shape.fields
+        .map((field) => eqHashFieldFromReflectedShape(ctx, field, macroName, typeName, declaration))
+        .filter((field) => field !== null);
+    return { fields, typeName };
+}
+function eqCheckText(field, leftName, rightName) {
+    const leftAccess = propertyAccessText(leftName, field.name);
+    const rightAccess = propertyAccessText(rightName, field.name);
+    if (!field.optional) {
+        return `${field.eqHelper}.equals(${leftAccess}, ${rightAccess})`;
+    }
+    return `${leftAccess} === ${rightAccess} || (${leftAccess} !== undefined && ${rightAccess} !== undefined && ${field.eqHelper}.equals(${leftAccess}, ${rightAccess}))`;
+}
+function hashExprText(field, receiverName) {
+    const access = propertyAccessText(receiverName, field.name);
+    if (!field.optional) {
+        return `${field.hashHelper}.hash(${access})`;
+    }
+    return `${access} === undefined ? 0 : ${field.hashHelper}.hash(${access})`;
+}
+function nestedEqHelperTextFromFields(ctx, ownerTypeName, scopeNode, fields) {
+    const derivedFields = fields.map((field) => eqHashFieldFromReflectedShape(ctx, field, 'eq', ownerTypeName, scopeNode)).filter((field) => field !== null);
+    const equalsBody = derivedFields.length === 0
+        ? 'true'
+        : derivedFields.map((field) => eqCheckText(field, 'left', 'right')).join(' && ');
+    return `({
+    equals(left, right) {
+      return ${equalsBody};
+    },
+  })`;
+}
+function nestedHashHelperTextFromFields(ctx, ownerTypeName, scopeNode, fields) {
+    const derivedFields = fields.map((field) => eqHashFieldFromReflectedShape(ctx, field, 'hash', ownerTypeName, scopeNode)).filter((field) => field !== null);
+    const fromHashEq = ctx.runtime.named('sts:hash', 'fromHashEq').text();
+    const combineHashes = ctx.runtime.named('sts:hash', 'combineHashes').text();
+    const hashArgs = derivedFields.map((field) => hashExprText(field, 'value')).join(', ');
+    const equalsBody = derivedFields.length === 0
+        ? 'true'
+        : derivedFields.map((field) => eqCheckText(field, 'left', 'right')).join(' && ');
+    return `${fromHashEq}(
+    (value) => ${combineHashes}(${hashArgs}),
+    (left, right) => ${equalsBody},
+  )`;
+}
+function nestedDecodeHelperTextFromFields(ctx, ownerTypeName, scopeNode, fields) {
+    const decodedFields = fields.map((field) => decodeFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode));
+    const decodeObject = ctx.runtime.named('sts:decode', 'object').text();
+    const decodeMap = ctx.runtime.named('sts:decode', 'map').text();
+    const decodeOptional = ctx.runtime.named('sts:decode', 'optional').text();
+    const shapeText = decodedFields.length === 0 ? '{}' : `{
+        ${decodedFields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${decodeOptional}(${field.decoderText})` : field.decoderText}`).join(',\n')}
+      }`;
+    const isIdentityProjection = decodedFields.every((field) => field.localName === field.wireName);
+    if (isIdentityProjection) {
+        return `${decodeObject}(${shapeText})`;
+    }
+    const projectionText = decodedFields.length === 0 ? '{}' : `({
+        ${decodedFields.map((field) => `${propertyKeyText(field.localName)}: ${propertyAccessText('value', field.wireName)}`).join(',\n')}
+      })`;
+    return `${decodeMap}(
+    ${decodeObject}(${shapeText}),
+    (value) => ${projectionText},
+  )`;
+}
+function nestedEncodeHelperTextFromFields(ctx, ownerTypeName, scopeNode, fields) {
+    const encodedFields = fields.map((field) => encodeFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode));
+    const encodeContramap = ctx.runtime.named('sts:encode', 'contramap').text();
+    const encodeObject = ctx.runtime.named('sts:encode', 'object').text();
+    const encodeOptional = ctx.runtime.named('sts:encode', 'optional').text();
+    const shapeText = encodedFields.length === 0 ? '{}' : `{
+        ${encodedFields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${encodeOptional}(${field.encoderText})` : field.encoderText}`).join(',\n')}
+      }`;
+    const isIdentityProjection = encodedFields.every((field) => field.localName === field.wireName);
+    if (isIdentityProjection) {
+        return `${encodeObject}(${shapeText})`;
+    }
+    const projectionText = encodedFields.length === 0 ? '({})' : `({
+        ${encodedFields.map((field) => `${propertyKeyText(field.wireName)}: ${propertyAccessText('value', field.localName)}`).join(',\n')}
+      })`;
+    return `${encodeContramap}(
+    ${encodeObject}(${shapeText}),
+    (value) => ${projectionText},
+  )`;
+}
+function nestedCodecHelperTextsFromFields(ctx, ownerTypeName, scopeNode, fields) {
+    const codecFields = fields.map((field) => codecFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode));
+    const decodeObject = ctx.runtime.named('sts:decode', 'object').text();
+    const decodeMap = ctx.runtime.named('sts:decode', 'map').text();
+    const decodeOptional = ctx.runtime.named('sts:decode', 'optional').text();
+    const encodeContramap = ctx.runtime.named('sts:encode', 'contramap').text();
+    const encodeObject = ctx.runtime.named('sts:encode', 'object').text();
+    const encodeOptional = ctx.runtime.named('sts:encode', 'optional').text();
+    const decodeShapeText = codecFields.length === 0 ? '{}' : `{
+        ${codecFields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${decodeOptional}(${field.decodeText})` : field.decodeText}`).join(',\n')}
+      }`;
+    const hasIdentityDecodeProjection = codecFields.every((field) => field.localName === field.wireName);
+    const encodeShapeText = codecFields.length === 0 ? '{}' : `{
+        ${codecFields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${encodeOptional}(${field.encodeText})` : field.encodeText}`).join(',\n')}
+      }`;
+    const hasIdentityEncodeProjection = codecFields.every((field) => field.localName === field.wireName);
+    return {
+        decodeText: hasIdentityDecodeProjection ? `${decodeObject}(${decodeShapeText})` : `${decodeMap}(
+      ${decodeObject}(${decodeShapeText}),
+      (value) => ({
+        ${codecFields.map((field) => `${propertyKeyText(field.localName)}: ${propertyAccessText('value', field.wireName)}`).join(',\n')}
+      }),
+    )`,
+        encodeText: hasIdentityEncodeProjection
+            ? `${encodeObject}(${encodeShapeText})`
+            : `${encodeContramap}(
+      ${encodeObject}(${encodeShapeText}),
+      (value) => ({
+        ${codecFields.map((field) => `${propertyKeyText(field.wireName)}: ${propertyAccessText('value', field.localName)}`).join(',\n')}
+      }),
+    )`,
+    };
+}
+function collectNestedDerivedFields(ctx, macroName, ownerTypeName, scopeNode, objectType) {
+    return objectType.members
+        .map((member) => fieldFromObjectMember(ctx, member, macroName, ownerTypeName, scopeNode))
+        .filter((member) => member !== null);
+}
+function nestedEqHelperText(ctx, ownerTypeName, scopeNode, objectType) {
+    const fields = collectNestedDerivedFields(ctx, 'eq', ownerTypeName, scopeNode, objectType);
+    const equalsBody = fields.length === 0
+        ? 'true'
+        : fields.map((field) => eqCheckText(field, 'left', 'right')).join(' && ');
+    return `({
+    equals(left, right) {
+      return ${equalsBody};
+    },
+  })`;
+}
+function nestedHashHelperText(ctx, ownerTypeName, scopeNode, objectType) {
+    const fields = collectNestedDerivedFields(ctx, 'hash', ownerTypeName, scopeNode, objectType);
+    const fromHashEq = ctx.runtime.named('sts:hash', 'fromHashEq').text();
+    const combineHashes = ctx.runtime.named('sts:hash', 'combineHashes').text();
+    const hashArgs = fields.map((field) => hashExprText(field, 'value')).join(', ');
+    const equalsBody = fields.length === 0
+        ? 'true'
+        : fields.map((field) => eqCheckText(field, 'left', 'right')).join(' && ');
+    return `${fromHashEq}(
+    (value) => ${combineHashes}(${hashArgs}),
+    (left, right) => ${equalsBody},
+  )`;
+}
+function nestedDecodeHelperText(ctx, ownerTypeName, scopeNode, objectType) {
+    const fields = objectType.members.map((member) => fieldFromDecodeMember(ctx, member, ownerTypeName, scopeNode));
+    const decodeObject = ctx.runtime.named('sts:decode', 'object').text();
+    const decodeMap = ctx.runtime.named('sts:decode', 'map').text();
+    const decodeOptional = ctx.runtime.named('sts:decode', 'optional').text();
+    const shapeText = fields.length === 0 ? '{}' : `{
+        ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${decodeOptional}(${field.decoderText})` : field.decoderText}`).join(',\n')}
+      }`;
+    const isIdentityProjection = fields.every((field) => field.localName === field.wireName);
+    if (isIdentityProjection) {
+        return `${decodeObject}(${shapeText})`;
+    }
+    const projectionText = fields.length === 0 ? '{}' : `({
+        ${fields.map((field) => `${propertyKeyText(field.localName)}: ${propertyAccessText('value', field.wireName)}`).join(',\n')}
+      })`;
+    return `${decodeMap}(
+    ${decodeObject}(${shapeText}),
+    (value) => ${projectionText},
+  )`;
+}
+function nestedEncodeHelperText(ctx, ownerTypeName, scopeNode, objectType) {
+    const fields = objectType.members.map((member) => fieldFromEncodeMember(ctx, member, ownerTypeName, scopeNode));
+    const encodeContramap = ctx.runtime.named('sts:encode', 'contramap').text();
+    const encodeObject = ctx.runtime.named('sts:encode', 'object').text();
+    const encodeOptional = ctx.runtime.named('sts:encode', 'optional').text();
+    const shapeText = fields.length === 0 ? '{}' : `{
+        ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${encodeOptional}(${field.encoderText})` : field.encoderText}`).join(',\n')}
+      }`;
+    const isIdentityProjection = fields.every((field) => field.localName === field.wireName);
+    if (isIdentityProjection) {
+        return `${encodeObject}(${shapeText})`;
+    }
+    const projectionText = fields.length === 0 ? '({})' : `({
+        ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${propertyAccessText('value', field.localName)}`).join(',\n')}
+      })`;
+    return `${encodeContramap}(
+    ${encodeObject}(${shapeText}),
+    (value) => ${projectionText},
+  )`;
+}
+function nestedCodecHelperTexts(ctx, ownerTypeName, scopeNode, objectType) {
+    const fields = objectType.members.map((member) => fieldFromCodecMember(ctx, member, ownerTypeName, scopeNode));
+    const decodeObject = ctx.runtime.named('sts:decode', 'object').text();
+    const decodeMap = ctx.runtime.named('sts:decode', 'map').text();
+    const decodeOptional = ctx.runtime.named('sts:decode', 'optional').text();
+    const encodeContramap = ctx.runtime.named('sts:encode', 'contramap').text();
+    const encodeObject = ctx.runtime.named('sts:encode', 'object').text();
+    const encodeOptional = ctx.runtime.named('sts:encode', 'optional').text();
+    const decodeShapeText = fields.length === 0 ? '{}' : `{
+        ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${decodeOptional}(${field.decodeText})` : field.decodeText}`).join(',\n')}
+      }`;
+    const hasIdentityDecodeProjection = fields.every((field) => field.localName === field.wireName);
+    const encodeShapeText = fields.length === 0 ? '{}' : `{
+        ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${encodeOptional}(${field.encodeText})` : field.encodeText}`).join(',\n')}
+      }`;
+    const hasIdentityEncodeProjection = fields.every((field) => field.localName === field.wireName);
+    return {
+        decodeText: hasIdentityDecodeProjection ? `${decodeObject}(${decodeShapeText})` : `${decodeMap}(
+      ${decodeObject}(${decodeShapeText}),
+      (value) => ({
+        ${fields.map((field) => `${propertyKeyText(field.localName)}: ${propertyAccessText('value', field.wireName)}`).join(',\n')}
+      }),
+    )`,
+        encodeText: hasIdentityEncodeProjection
+            ? `${encodeObject}(${encodeShapeText})`
+            : `${encodeContramap}(
+      ${encodeObject}(${encodeShapeText}),
+      (value) => ({
+        ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${propertyAccessText('value', field.localName)}`).join(',\n')}
+      }),
+    )`,
+    };
+}
+function capitalizeName(name) {
+    return name.length === 0 ? name : `${name[0].toUpperCase()}${name.slice(1)}`;
+}
+function decapitalizeName(name) {
+    return name.length === 0 ? name : `${name[0].toLowerCase()}${name.slice(1)}`;
+}
+function annotationNamedStringArgument(annotation, name) {
+    const argument = annotation.arguments?.find((entry) => entry.kind === 'named' && entry.name === name);
+    return argument?.value.kind === 'string' ? argument.value.value : null;
+}
+function taggedDiscriminantName(ctx, declaration) {
+    const annotation = findAnnotation(ctx.syntax.annotations(declaration), 'tagged');
+    if (!annotation) {
+        return 'tag';
+    }
+    const discriminant = annotationNamedStringArgument(annotation, 'discriminant');
+    if (discriminant !== null) {
+        return discriminant;
+    }
+    if ((annotation.arguments?.length ?? 0) > 0) {
+        ctx.error("tagged only supports #[tagged(discriminant: '...')] options in v1.", declaration);
+    }
+    return 'tag';
+}
+function taggedPayloadField(ctx, member) {
+    if (member.memberKind !== 'property_signature' || member.name === null) {
+        ctx.error('tagged only supports property-style object members in v1.', member);
+    }
+    const explicitType = member.explicitType();
+    if (!explicitType) {
+        ctx.error('tagged currently requires explicit payload property types in v1.', member);
+    }
+    return {
+        name: member.name,
+        optional: member.isOptional(),
+        typeText: explicitType.text(),
+    };
+}
+function fieldFromDecodeMember(ctx, member, ownerTypeName, scopeNode) {
+    if (member.memberKind !== 'property_signature' || member.name === null) {
+        ctx.error('decode only supports property-style object members in v1.', member);
+    }
+    const viaAnnotation = findAnnotation(ctx.syntax.annotations(member), 'decode.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('decode.via(...) requires a helper identifier.', member);
+    }
+    const renameAnnotation = findAnnotation(ctx.syntax.annotations(member), 'decode.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('decode.rename(...) requires a string field name.', member);
+    }
+    const explicitType = member.explicitType();
+    if (!explicitType) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('decode'), member);
+    }
+    const decoderText = (() => {
+        if (viaIdentifier) {
+            return viaIdentifier;
+        }
+        const objectType = explicitType.asObjectLiteral();
+        if (objectType) {
+            return nestedDecodeHelperText(ctx, ownerTypeName, scopeNode, objectType);
+        }
+        const fieldType = parseSupportedDerivedType(explicitType.text());
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('decode'), member);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'decode', ownerTypeName, scopeNode, member, fieldType);
+        return decodeHelperTextForType(ctx, fieldType);
+    })();
+    return {
+        decoderText,
+        localName: member.name,
+        optional: member.isOptional(),
+        wireName: renamedWireName ?? member.name,
+    };
+}
+function fieldFromDecodeClassField(ctx, field, ownerTypeName, scopeNode) {
+    if (field.hasModifier('private') || field.hasModifier('protected') || field.hasModifier('static') ||
+        field.name === null) {
+        return null;
+    }
+    const viaAnnotation = findAnnotation(ctx.syntax.annotations(field), 'decode.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('decode.via(...) requires a helper identifier.', field);
+    }
+    const renameAnnotation = findAnnotation(ctx.syntax.annotations(field), 'decode.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('decode.rename(...) requires a string field name.', field);
+    }
+    const explicitType = field.explicitType();
+    if (!explicitType) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('decode'), field);
+    }
+    const decoderText = (() => {
+        if (viaIdentifier) {
+            return viaIdentifier;
+        }
+        const objectType = explicitType.asObjectLiteral();
+        if (objectType) {
+            return nestedDecodeHelperText(ctx, ownerTypeName, scopeNode, objectType);
+        }
+        const fieldType = parseSupportedDerivedType(explicitType.text());
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('decode'), field);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'decode', ownerTypeName, scopeNode, field, fieldType);
+        return decodeHelperTextForType(ctx, fieldType);
+    })();
+    return {
+        decoderText,
+        localName: field.name,
+        optional: field.isOptional(),
+        wireName: renamedWireName ?? field.name,
+    };
+}
+function classHasConstructorParameters(declaration) {
+    return declaration.members().some((member) => member.memberKind === 'constructor' && member.parameters.length > 0);
+}
+function classifySelfFactoryHelper(declaration, typeName, factoryIdentifier) {
+    const segments = factoryIdentifier.split('.').map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+    if (segments.length !== 2 || segments[0] !== typeName) {
+        return null;
+    }
+    const member = declaration.member(segments[1]);
+    if (!member || !member.hasModifier('static')) {
+        return 'missing';
+    }
+    return member.memberKind === 'method' ? 'callable' : 'non-callable';
+}
+function classDecodeInstantiateText(ctx, declaration, macroName, typeName) {
+    const factoryAnnotation = findAnnotation(ctx.syntax.annotations(declaration), `${macroName}.factory`);
+    if (factoryAnnotation) {
+        const factoryIdentifier = annotationIdentifierArgument(factoryAnnotation);
+        if (!factoryIdentifier) {
+            ctx.error(`${macroName}.factory(...) requires a helper identifier.`, annotationDiagnosticNode(declaration, factoryAnnotation) ?? declaration);
+        }
+        const selfFactoryClassification = classifySelfFactoryHelper(declaration, typeName, factoryIdentifier);
+        if (selfFactoryClassification === 'missing') {
+            ctx.error(`${macroName}.factory(...) requires the helper value "${factoryIdentifier}" to be in scope.`, annotationDiagnosticNode(declaration, factoryAnnotation) ?? declaration);
+        }
+        if (selfFactoryClassification === 'non-callable') {
+            ctx.error(`${macroName}.factory(...) requires "${factoryIdentifier}" to be callable.`, annotationDiagnosticNode(declaration, factoryAnnotation) ?? declaration);
+        }
+        if (selfFactoryClassification === 'callable') {
+            return `${factoryIdentifier}(${CLASS_DECODE_VALUE_PLACEHOLDER})`;
+        }
+        if (!ctx.semantics.valueBindingInScope(factoryIdentifier)) {
+            ctx.error(`${macroName}.factory(...) requires the helper value "${factoryIdentifier}" to be in scope.`, annotationDiagnosticNode(declaration, factoryAnnotation) ?? declaration);
+        }
+        if (!ctx.semantics.valueBindingCallableInScope(factoryIdentifier)) {
+            ctx.error(`${macroName}.factory(...) requires "${factoryIdentifier}" to be callable.`, annotationDiagnosticNode(declaration, factoryAnnotation) ?? declaration);
+        }
+        return `${factoryIdentifier}(${CLASS_DECODE_VALUE_PLACEHOLDER})`;
+    }
+    if (classHasConstructorParameters(declaration)) {
+        ctx.error(`${macroName} class support in v1 requires a constructor with no parameters.`, declaration);
+    }
+    return `Object.assign(new ${typeName}(), ${CLASS_DECODE_VALUE_PLACEHOLDER})`;
+}
+function collectDecodeFields(ctx, decoded) {
+    const declaration = decoded.args.target;
+    const shape = objectLikeDeclarationShape(ctx, declaration, 'decode');
+    const typeName = shape.name ??
+        ctx.error(`decode currently requires named ${shape.declarationKind} declarations.`, declaration);
+    return {
+        fields: shape.fields.map((field) => decodeFieldFromReflectedShape(ctx, field, typeName, declaration)),
+        instantiateText: decoded.caseName === 'class'
+            ? classDecodeInstantiateText(ctx, declaration, 'decode', typeName)
+            : null,
+        typeName,
+    };
+}
+function fieldFromEncodeMember(ctx, member, ownerTypeName, scopeNode) {
+    if (member.memberKind !== 'property_signature' || member.name === null) {
+        ctx.error('encode only supports property-style object members in v1.', member);
+    }
+    const viaAnnotation = findAnnotation(ctx.syntax.annotations(member), 'encode.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('encode.via(...) requires a helper identifier.', member);
+    }
+    const renameAnnotation = findAnnotation(ctx.syntax.annotations(member), 'encode.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('encode.rename(...) requires a string field name.', member);
+    }
+    const explicitType = member.explicitType();
+    if (!explicitType) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('encode'), member);
+    }
+    const encoderText = (() => {
+        if (viaIdentifier) {
+            return viaIdentifier;
+        }
+        const objectType = explicitType.asObjectLiteral();
+        if (objectType) {
+            return nestedEncodeHelperText(ctx, ownerTypeName, scopeNode, objectType);
+        }
+        const fieldType = parseSupportedDerivedType(explicitType.text());
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('encode'), member);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'encode', ownerTypeName, scopeNode, member, fieldType);
+        return encodeHelperTextForType(ctx, fieldType);
+    })();
+    return {
+        encoderText,
+        localName: member.name,
+        optional: member.isOptional(),
+        wireName: renamedWireName ?? member.name,
+    };
+}
+function fieldFromEncodeClassField(ctx, field, ownerTypeName, scopeNode) {
+    if (field.hasModifier('private') || field.hasModifier('protected') || field.hasModifier('static') ||
+        field.name === null) {
+        return null;
+    }
+    const viaAnnotation = findAnnotation(ctx.syntax.annotations(field), 'encode.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('encode.via(...) requires a helper identifier.', field);
+    }
+    const renameAnnotation = findAnnotation(ctx.syntax.annotations(field), 'encode.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('encode.rename(...) requires a string field name.', field);
+    }
+    const explicitType = field.explicitType();
+    if (!explicitType) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('encode'), field);
+    }
+    const encoderText = (() => {
+        if (viaIdentifier) {
+            return viaIdentifier;
+        }
+        const objectType = explicitType.asObjectLiteral();
+        if (objectType) {
+            return nestedEncodeHelperText(ctx, ownerTypeName, scopeNode, objectType);
+        }
+        const fieldType = parseSupportedDerivedType(explicitType.text());
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('encode'), field);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'encode', ownerTypeName, scopeNode, field, fieldType);
+        return encodeHelperTextForType(ctx, fieldType);
+    })();
+    return {
+        encoderText,
+        localName: field.name,
+        optional: field.isOptional(),
+        wireName: renamedWireName ?? field.name,
+    };
+}
+function collectEncodeFields(ctx, decoded) {
+    const declaration = decoded.args.target;
+    const shape = objectLikeDeclarationShape(ctx, declaration, 'encode');
+    const typeName = shape.name ??
+        ctx.error(`encode currently requires named ${shape.declarationKind} declarations.`, declaration);
+    return {
+        fields: shape.fields.map((field) => encodeFieldFromReflectedShape(ctx, field, typeName, declaration)),
+        typeName,
+    };
+}
+function fieldFromCodecMember(ctx, member, ownerTypeName, scopeNode) {
+    if (member.memberKind !== 'property_signature' || member.name === null) {
+        ctx.error('codec only supports property-style object members in v1.', member);
+    }
+    const viaAnnotation = findAnnotation(ctx.syntax.annotations(member), 'codec.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('codec.via(...) requires a helper identifier.', member);
+    }
+    const renameAnnotation = findAnnotation(ctx.syntax.annotations(member), 'codec.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('codec.rename(...) requires a string field name.', member);
+    }
+    const explicitType = member.explicitType();
+    if (!explicitType) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('codec'), member);
+    }
+    const helperTexts = (() => {
+        if (viaIdentifier) {
+            return { decodeText: viaIdentifier, encodeText: viaIdentifier };
+        }
+        const objectType = explicitType.asObjectLiteral();
+        if (objectType) {
+            return nestedCodecHelperTexts(ctx, ownerTypeName, scopeNode, objectType);
+        }
+        const fieldType = parseSupportedDerivedType(explicitType.text());
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('codec'), member);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'codec', ownerTypeName, scopeNode, member, fieldType);
+        return codecHelperTextsForType(ctx, fieldType);
+    })();
+    return {
+        decodeText: helperTexts.decodeText,
+        encodeText: helperTexts.encodeText,
+        localName: member.name,
+        optional: member.isOptional(),
+        wireName: renamedWireName ?? member.name,
+    };
+}
+function fieldFromCodecClassField(ctx, field, ownerTypeName, scopeNode) {
+    if (field.hasModifier('private') || field.hasModifier('protected') || field.hasModifier('static') ||
+        field.name === null) {
+        return null;
+    }
+    const viaAnnotation = findAnnotation(ctx.syntax.annotations(field), 'codec.via');
+    const viaIdentifier = viaAnnotation ? annotationIdentifierArgument(viaAnnotation) : null;
+    if (viaAnnotation && !viaIdentifier) {
+        ctx.error('codec.via(...) requires a helper identifier.', field);
+    }
+    const renameAnnotation = findAnnotation(ctx.syntax.annotations(field), 'codec.rename');
+    const renamedWireName = renameAnnotation ? annotationStringArgument(renameAnnotation) : null;
+    if (renameAnnotation && !renamedWireName) {
+        ctx.error('codec.rename(...) requires a string field name.', field);
+    }
+    const explicitType = field.explicitType();
+    if (!explicitType) {
+        ctx.error(decodeLikeUnsupportedFieldMessage('codec'), field);
+    }
+    const helperTexts = (() => {
+        if (viaIdentifier) {
+            return { decodeText: viaIdentifier, encodeText: viaIdentifier };
+        }
+        const objectType = explicitType.asObjectLiteral();
+        if (objectType) {
+            return nestedCodecHelperTexts(ctx, ownerTypeName, scopeNode, objectType);
+        }
+        const fieldType = parseSupportedDerivedType(explicitType.text());
+        if (!fieldType) {
+            ctx.error(decodeLikeUnsupportedFieldMessage('codec'), field);
+        }
+        assertNamedDerivedCompanionsInScope(ctx, 'codec', ownerTypeName, scopeNode, field, fieldType);
+        return codecHelperTextsForType(ctx, fieldType);
+    })();
+    return {
+        decodeText: helperTexts.decodeText,
+        encodeText: helperTexts.encodeText,
+        localName: field.name,
+        optional: field.isOptional(),
+        wireName: renamedWireName ?? field.name,
+    };
+}
+function collectCodecFields(ctx, decoded) {
+    const declaration = decoded.args.target;
+    const shape = objectLikeDeclarationShape(ctx, declaration, 'codec');
+    const typeName = shape.name ??
+        ctx.error(`codec currently requires named ${shape.declarationKind} declarations.`, declaration);
+    return {
+        fields: shape.fields.map((field) => codecFieldFromReflectedShape(ctx, field, typeName, declaration)),
+        instantiateText: decoded.caseName === 'class'
+            ? classDecodeInstantiateText(ctx, declaration, 'codec', typeName)
+            : null,
+        typeName,
+    };
+}
+function validateTaggedUnionSyntaxForDiagnostics(ctx, declaration, macroName, discriminantName) {
+    const unionType = declaration.type.asUnion();
+    if (!unionType) {
+        if (macroName === 'tagged') {
+            ctx.error('tagged currently only supports type aliases declared as unions in v1.', declaration);
+        }
+        ctx.error(`${macroName} currently only supports object-like type aliases.`, declaration);
+    }
+    for (const member of unionType.members) {
+        const objectType = member.asObjectLiteral();
+        if (!objectType) {
+            ctx.error(macroName === 'tagged'
+                ? 'tagged only supports unions of object-like variants in v1.'
+                : `${macroName} only supports // #[tagged] unions of object-like variants in v1.`, declaration);
+        }
+        let hasDiscriminant = false;
+        for (const objectMember of objectType.members) {
+            if (objectMember.memberKind !== 'property_signature' || objectMember.name === null) {
+                ctx.error(macroName === 'tagged'
+                    ? 'tagged only supports property-style object members in v1.'
+                    : `${macroName} only supports property-style tagged union members in v1.`, objectMember);
+            }
+            if (objectMember.name !== discriminantName) {
+                continue;
+            }
+            const literalType = objectMember.explicitType()?.asLiteral();
+            if (!literalType || literalType.literalKind !== 'string') {
+                ctx.error(macroName === 'tagged'
+                    ? 'tagged requires each variant discriminant to be a string literal type in v1.'
+                    : `${macroName} requires each tagged union discriminant to be a string literal type in v1.`, objectMember);
+            }
+            hasDiscriminant = true;
+        }
+        if (!hasDiscriminant) {
+            ctx.error(macroName === 'tagged'
+                ? `tagged requires each variant to declare the discriminant property "${discriminantName}".`
+                : `${macroName} requires each tagged variant to declare the discriminant property "${discriminantName}".`, objectType);
+        }
+    }
+    ctx.error(macroName === 'tagged'
+        ? 'tagged only supports unions of object-like variants in v1.'
+        : `${macroName} only supports // #[tagged] unions of object-like variants in v1.`, declaration);
+}
+function collectTaggedDerivedVariants(ctx, declaration, macroName, collectField) {
+    const discriminantName = taggedDiscriminantName(ctx, declaration);
+    const shape = ctx.reflect.declarationShape(declaration);
+    if (shape.kind !== 'discriminatedUnion') {
+        return validateTaggedUnionSyntaxForDiagnostics(ctx, declaration, macroName, discriminantName);
+    }
+    const unionShape = shape;
+    const typeName = unionShape.name ??
+        ctx.error(`${macroName} currently requires named type aliases.`, declaration);
+    const variants = unionShape.variants.map((variant) => {
+        const discriminant = variant.discriminants.find((entry) => entry.name === discriminantName);
+        if (!discriminant) {
+            ctx.error(`${macroName} requires each tagged variant to declare the discriminant property "${discriminantName}".`, variant.node);
+        }
+        const fields = [];
+        for (const reflectedField of variant.fields) {
+            const field = collectField(reflectedField, typeName, declaration);
+            if (field !== null) {
+                fields.push(field);
+            }
+        }
+        return {
+            fields,
+            tag: discriminant.tag,
+        };
+    });
+    return { discriminantName, typeName, variants };
+}
+function taggedVariantTypeText(typeName, discriminantName, tag) {
+    return `Extract<${typeName}, { ${propertyKeyText(discriminantName)}: "${tag}" }>`;
+}
+function foldUnionText(helperText, expressions) {
+    const [first, ...rest] = expressions;
+    if (!first) {
+        throw new Error('foldUnionText requires at least one expression.');
+    }
+    return rest.reduce((current, expression) => `${helperText}(${current}, ${expression})`, first);
+}
+function collectTaggedVariants(ctx, declaration) {
+    const shape = ctx.reflect.declarationShape(declaration);
+    if (shape.kind === 'discriminatedUnion') {
+        const discriminantName = taggedDiscriminantName(ctx, declaration);
+        const unionShape = shape;
+        const typeName = unionShape.name ??
+            ctx.error('tagged currently requires named type aliases.', declaration);
+        const seenTags = new Set();
+        const variants = unionShape.variants.map((variant) => {
+            const discriminant = variant.discriminants.find((entry) => entry.name === discriminantName);
+            if (!discriminant) {
+                ctx.error(`tagged requires each variant to declare the discriminant property "${discriminantName}".`, variant.node);
+            }
+            if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(discriminant.tag)) {
+                ctx.error('tagged requires identifier-safe string literal tags in v1.', variant.node);
+            }
+            if (seenTags.has(discriminant.tag)) {
+                ctx.error(`tagged requires unique "${discriminantName}" variant tags.`, variant.node);
+            }
+            seenTags.add(discriminant.tag);
+            return {
+                constructorName: discriminant.tag,
+                constructorTypeParametersText: '',
+                kind: 'object',
+                payloadFields: variant.fields.map((field) => {
+                    if (!field.type) {
+                        ctx.error('tagged currently requires explicit payload property types in v1.', field.node);
+                    }
+                    return {
+                        name: field.name,
+                        optional: field.optional,
+                        typeText: field.type.text,
+                    };
+                }),
+                predicateConditionText: `${propertyAccessText('value', discriminantName)} === '${discriminant.tag}'`,
+                predicateName: `is${capitalizeName(discriminant.tag)}`,
+                predicateNarrowTypeText: `Extract<${typeName}, { ${propertyKeyText(discriminantName)}: "${discriminant.tag}" }>`,
+                predicateTypeParametersText: '',
+                predicateValueTypeText: typeName,
+                returnExpressionText: variant.fields.length === 0
+                    ? `{ ${propertyKeyText(discriminantName)}: '${discriminant.tag}' }`
+                    : `{ ${propertyKeyText(discriminantName)}: '${discriminant.tag}', ...payload }`,
+            };
+        });
+        return { discriminantName, typeName, variants };
+    }
+    const unionType = declaration.type.asUnion();
+    if (!unionType) {
+        return validateTaggedUnionSyntaxForDiagnostics(ctx, declaration, 'tagged', taggedDiscriminantName(ctx, declaration));
+    }
+    if (unionType.members.every((member) => member.asObjectLiteral() !== null)) {
+        return validateTaggedUnionSyntaxForDiagnostics(ctx, declaration, 'tagged', taggedDiscriminantName(ctx, declaration));
+    }
+    const hostDeclaration = getHostDeclaration(declaration);
+    if (!ts.isTypeAliasDeclaration(hostDeclaration)) {
+        return validateTaggedUnionSyntaxForDiagnostics(ctx, declaration, 'tagged', taggedDiscriminantName(ctx, declaration));
+    }
+    const sourceFile = hostDeclaration.getSourceFile();
+    const hostUnionType = ts.isUnionTypeNode(hostDeclaration.type)
+        ? hostDeclaration.type
+        : undefined;
+    if (!hostUnionType) {
+        return validateTaggedUnionSyntaxForDiagnostics(ctx, declaration, 'tagged', taggedDiscriminantName(ctx, declaration));
+    }
+    const typeName = hostDeclaration.name?.text ??
+        ctx.error('tagged currently requires named type aliases.', declaration);
+    const aliasTypeParameters = hostDeclaration.typeParameters?.map((parameter) => parameter.getText(sourceFile)) ?? [];
+    const aliasTypeParametersText = aliasTypeParameters.length === 0
+        ? ''
+        : `<${aliasTypeParameters.join(', ')}>`;
+    const aliasAppliedTypeText = `${typeName}${aliasTypeParametersText}`;
+    const variants = hostUnionType.types.map((hostMember, index) => {
+        if (!ts.isTypeReferenceNode(hostMember)) {
+            ctx.error('tagged only supports unions of object-like variants or named classes in the same module in v1.', declaration);
+        }
+        const member = unionType.members[index];
+        if (!member) {
+            ctx.error('tagged only supports unions of object-like variants or named classes in the same module in v1.', declaration);
+        }
+        const classDeclaration = ctx.semantics.classDeclarationOfType(member);
+        if (!classDeclaration || classDeclaration.span.fileName !== sourceFile.fileName) {
+            ctx.error('tagged only supports unions of object-like variants or named classes in the same module in v1.', declaration);
+        }
+        const className = classDeclaration.name ??
+            ctx.error('tagged only supports unions of object-like variants or named classes in the same module in v1.', declaration);
+        const constructor = classDeclaration.members().find((classMember) => classMember.memberKind === 'constructor');
+        const payloadFields = constructor
+            ? constructor.parameters.map((parameter) => {
+                const explicitType = parameter.explicitType();
+                if (!parameter.name || !explicitType) {
+                    ctx.error('tagged value-class variants require constructors with simple identifier parameters and explicit types in v1.', declaration);
+                }
+                return {
+                    name: parameter.name,
+                    optional: false,
+                    typeText: explicitType.text(),
+                };
+            })
+            : [];
+        const variantTypeParameters = hostMember.typeArguments?.flatMap((typeArgument) => ts.isTypeReferenceNode(typeArgument) && ts.isIdentifier(typeArgument.typeName) &&
+            !typeArgument.typeArguments?.length
+            ? [typeArgument.typeName.text]
+            : []) ?? [];
+        const variantTypeParametersText = variantTypeParameters.length === 0
+            ? ''
+            : `<${variantTypeParameters.join(', ')}>`;
+        return {
+            constructorName: decapitalizeName(className),
+            constructorTypeParametersText: variantTypeParametersText,
+            kind: 'class',
+            payloadFields,
+            predicateConditionText: `value instanceof ${className}`,
+            predicateName: `is${className}`,
+            predicateNarrowTypeText: hostMember.getText(sourceFile),
+            predicateTypeParametersText: aliasTypeParametersText,
+            predicateValueTypeText: aliasAppliedTypeText,
+            returnExpressionText: payloadFields.length === 0
+                ? `new ${className}()`
+                : `new ${className}(${payloadFields.map((field) => field.name).join(', ')})`,
+        };
+    });
+    return {
+        discriminantName: null,
+        typeName,
+        variants,
+    };
+}
+function taggedPayloadTypeText(fields) {
+    if (fields.length === 0) {
+        return '{}';
+    }
+    return `{ ${fields.map((field) => `${propertyKeyText(field.name)}${field.optional ? '?' : ''}: ${field.typeText}`).join('; ')} }`;
+}
+function taggedConstructorText(discriminantName, typeName, variant) {
+    const returnType = variant.kind === 'class' ? variant.predicateNarrowTypeText : typeName;
+    const parameterText = variant.payloadFields.length === 0
+        ? ''
+        : variant.kind === 'class'
+            ? variant.payloadFields.map((field) => `${field.name}: ${field.typeText}`).join(', ')
+            : `payload: ${taggedPayloadTypeText(variant.payloadFields)}`;
+    const typeParametersText = variant.constructorTypeParametersText;
+    if (parameterText.length === 0) {
+        return `${variant.constructorName}${typeParametersText}(): ${returnType} {
+      return ${variant.returnExpressionText};
+    }`;
+    }
+    return `${variant.constructorName}${typeParametersText}(${parameterText}): ${returnType} {
+    return ${variant.returnExpressionText};
+  }`;
+}
+function taggedPredicateText(_discriminantName, _typeName, variant) {
+    return `${variant.predicateName}${variant.predicateTypeParametersText}(value: ${variant.predicateValueTypeText}): value is ${variant.predicateNarrowTypeText} {
+    return ${variant.predicateConditionText};
+  }`;
+}
+function taggedEqCaseText(discriminantName, typeName, variant) {
+    const rightName = `right${capitalizeName(variant.tag)}`;
+    const equalsBody = variant.fields.length === 0
+        ? 'true'
+        : variant.fields.map((field) => eqCheckText(field, 'left', rightName)).join(' && ');
+    return `case '${variant.tag}': {
+    const ${rightName} = right as ${taggedVariantTypeText(typeName, discriminantName, variant.tag)};
+    return ${equalsBody};
+  }`;
+}
+function taggedHashCaseText(discriminantName, typeName, variant, stringHashText, combineHashesText) {
+    const rightName = `right${capitalizeName(variant.tag)}`;
+    const payloadHashes = variant.fields.map((field) => hashExprText(field, 'value'));
+    const hashExpr = `${combineHashesText}(${[
+        `${stringHashText}.hash(${JSON.stringify(variant.tag)})`,
+        ...payloadHashes,
+    ].join(', ')})`;
+    const equalsBody = variant.fields.length === 0
+        ? 'true'
+        : variant.fields.map((field) => eqCheckText(field, 'value', rightName)).join(' && ');
+    return `case '${variant.tag}': {
+    if (mode === 'hash') {
+      return ${hashExpr};
+    }
+    const ${rightName} = right as ${taggedVariantTypeText(typeName, discriminantName, variant.tag)};
+    return ${equalsBody};
+  }`;
+}
+function taggedDecodeVariantText(discriminantName, variant, decodeLiteralText, decodeMapText, decodeObjectText, decodeOptionalText) {
+    const shapeEntries = [
+        `${propertyKeyText(discriminantName)}: ${decodeLiteralText}(${JSON.stringify(variant.tag)})`,
+        ...variant.fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${decodeOptionalText}(${field.decoderText})` : field.decoderText}`),
+    ];
+    const projectionEntries = [
+        `${propertyKeyText(discriminantName)}: ${JSON.stringify(variant.tag)}`,
+        ...variant.fields.map((field) => `${propertyKeyText(field.localName)}: ${propertyAccessText('value', field.wireName)}`),
+    ];
+    return `${decodeMapText}(
+    ${decodeObjectText}({
+      ${shapeEntries.join(',\n')}
+    }),
+    (value) => ({
+      ${projectionEntries.join(',\n')}
+    }),
+  )`;
+}
+function taggedEncodeVariantProjectionText(discriminantName, variant, receiverName) {
+    return `({
+    ${[
+        `${propertyKeyText(discriminantName)}: ${JSON.stringify(variant.tag)}`,
+        ...variant.fields.map((field) => `${propertyKeyText(field.wireName)}: ${propertyAccessText(receiverName, field.localName)}`),
+    ].join(',\n')}
+  })`;
+}
+function taggedEncodeVariantShapeText(discriminantName, variant, encodeOptionalText, stringEncoderText) {
+    return `{
+    ${[
+        `${propertyKeyText(discriminantName)}: ${stringEncoderText}`,
+        ...variant.fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${encodeOptionalText}(${field.encoderText})` : field.encoderText}`),
+    ].join(',\n')}
+  }`;
+}
+function taggedCodecDecodeVariantText(discriminantName, variant, decodeLiteralText, decodeMapText, decodeObjectText, decodeOptionalText) {
+    const shapeEntries = [
+        `${propertyKeyText(discriminantName)}: ${decodeLiteralText}(${JSON.stringify(variant.tag)})`,
+        ...variant.fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${decodeOptionalText}(${field.decodeText})` : field.decodeText}`),
+    ];
+    const projectionEntries = [
+        `${propertyKeyText(discriminantName)}: ${JSON.stringify(variant.tag)}`,
+        ...variant.fields.map((field) => `${propertyKeyText(field.localName)}: ${propertyAccessText('value', field.wireName)}`),
+    ];
+    return `${decodeMapText}(
+    ${decodeObjectText}({
+      ${shapeEntries.join(',\n')}
+    }),
+    (value) => ({
+      ${projectionEntries.join(',\n')}
+    }),
+  )`;
+}
+function taggedCodecEncodeVariantShapeText(discriminantName, variant, encodeOptionalText, stringEncoderText) {
+    return `{
+    ${[
+        `${propertyKeyText(discriminantName)}: ${stringEncoderText}`,
+        ...variant.fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${encodeOptionalText}(${field.encodeText})` : field.encodeText}`),
+    ].join(',\n')}
+  }`;
+}
+function taggedCodecEncodeVariantProjectionText(discriminantName, variant, receiverName) {
+    return `({
+    ${[
+        `${propertyKeyText(discriminantName)}: ${JSON.stringify(variant.tag)}`,
+        ...variant.fields.map((field) => `${propertyKeyText(field.wireName)}: ${propertyAccessText(receiverName, field.localName)}`),
+    ].join(',\n')}
+  })`;
+}
+// #[macro(decl)]
+export function eq() {
+    return {
+        declarationKinds: ['class', 'interface', 'typeAlias'],
+        expansionMode: 'augment',
+        expand(ctx, decoded) {
+            if (decoded.caseName === 'typeAlias') {
+                const declaration = decoded.args.target;
+                if (!declaration.type.asObjectLiteral() && declaration.type.asUnion()) {
+                    const { discriminantName, typeName, variants } = collectTaggedDerivedVariants(ctx, declaration, 'eq', (field, ownerTypeName, scopeNode) => eqHashFieldFromReflectedShape(ctx, field, 'eq', ownerTypeName, scopeNode));
+                    const switchCases = variants.map((variant) => taggedEqCaseText(discriminantName, typeName, variant)).join('\n');
+                    return ctx.output.stmt(ctx.quote.stmt `
+              export const ${`${typeName}Eq`} = {
+                equals(left: ${typeName}, right: ${typeName}) {
+                  if (${propertyAccessText('left', discriminantName)} !== ${propertyAccessText('right', discriminantName)}) {
+                    return false;
+                  }
+                  switch (${propertyAccessText('left', discriminantName)}) {
+                    ${switchCases}
+                    default:
+                      return false;
+                  }
+                },
+              };
+            `);
+                }
+            }
+            const { fields, typeName } = collectFields(ctx, 'eq', decoded);
+            const equalsBody = fields.length === 0
+                ? 'true'
+                : fields.map((field) => eqCheckText(field, 'left', 'right')).join(' && ');
+            return ctx.output.stmt(ctx.quote.stmt `
+          export const ${`${typeName}Eq`} = {
+            equals(left: ${typeName}, right: ${typeName}) {
+              return ${equalsBody};
+            },
+          };
+        `);
+        },
+        signature: DERIVE_SIGNATURE,
+    };
+}
+attachDeriveFactory(eq);
+// #[macro(decl)]
+export function hash() {
+    return {
+        declarationKinds: ['class', 'interface', 'typeAlias'],
+        expansionMode: 'augment',
+        expand(ctx, decoded) {
+            if (decoded.caseName === 'typeAlias') {
+                const declaration = decoded.args.target;
+                if (!declaration.type.asObjectLiteral() && declaration.type.asUnion()) {
+                    const { discriminantName, typeName, variants } = collectTaggedDerivedVariants(ctx, declaration, 'hash', (field, ownerTypeName, scopeNode) => eqHashFieldFromReflectedShape(ctx, field, 'hash', ownerTypeName, scopeNode));
+                    const fromHashEq = ctx.runtime.named('sts:hash', 'fromHashEq').text();
+                    const combineHashes = ctx.runtime.named('sts:hash', 'combineHashes').text();
+                    const stringHash = ctx.runtime.named('sts:hash', 'stringHash').text();
+                    const switchCases = variants.map((variant) => taggedHashCaseText(discriminantName, typeName, variant, stringHash, combineHashes)).join('\n');
+                    return ctx.output.stmt(ctx.quote.stmt `
+              export const ${`${typeName}Hash`} = ${fromHashEq}<${typeName}>(
+                (value) => {
+                  const mode = 'hash' as const;
+                  switch (${propertyAccessText('value', discriminantName)}) {
+                    ${switchCases}
+                    default:
+                      return 0;
+                  }
+                },
+                (value, right) => {
+                  const mode = 'equals' as const;
+                  if (${propertyAccessText('value', discriminantName)} !== ${propertyAccessText('right', discriminantName)}) {
+                    return false;
+                  }
+                  switch (${propertyAccessText('value', discriminantName)}) {
+                    ${switchCases}
+                    default:
+                      return false;
+                  }
+                },
+              );
+            `);
+                }
+            }
+            const { fields, typeName } = collectFields(ctx, 'hash', decoded);
+            const fromHashEq = ctx.runtime.named('sts:hash', 'fromHashEq').text();
+            const combineHashes = ctx.runtime.named('sts:hash', 'combineHashes').text();
+            const hashArgs = fields.map((field) => hashExprText(field, 'value')).join(', ');
+            const equalsBody = fields.length === 0
+                ? 'true'
+                : fields.map((field) => eqCheckText(field, 'left', 'right')).join(' && ');
+            return ctx.output.stmt(ctx.quote.stmt `
+          export const ${`${typeName}Hash`} = ${fromHashEq}<${typeName}>(
+            (value) => ${combineHashes}(${hashArgs}),
+            (left, right) => ${equalsBody},
+          );
+        `);
+        },
+        signature: DERIVE_SIGNATURE,
+    };
+}
+attachDeriveFactory(hash);
+// #[macro(decl)]
+export function tagged() {
+    return {
+        declarationKinds: ['typeAlias'],
+        expansionMode: 'augment',
+        expand(ctx, decoded) {
+            const declaration = decoded.args.target;
+            const { discriminantName, typeName, variants } = collectTaggedVariants(ctx, declaration);
+            const companionMembers = variants.flatMap((variant) => [
+                taggedConstructorText(discriminantName, typeName, variant),
+                taggedPredicateText(discriminantName, typeName, variant),
+            ]).join(',\n');
+            return ctx.output.stmt(ctx.quote.stmt `
+          export const ${`${typeName}Tagged`} = {
+            ${companionMembers}
+          };
+        `);
+        },
+        signature: TAGGED_SIGNATURE,
+    };
+}
+attachDeriveFactory(tagged);
+// #[macro(decl)]
+export function decode() {
+    return {
+        declarationKinds: ['class', 'interface', 'typeAlias'],
+        expansionMode: 'augment',
+        expand(ctx, decoded) {
+            if (decoded.caseName === 'typeAlias') {
+                const declaration = decoded.args.target;
+                if (!declaration.type.asObjectLiteral() && declaration.type.asUnion()) {
+                    const { discriminantName, typeName, variants } = collectTaggedDerivedVariants(ctx, declaration, 'decode', (field, ownerTypeName, scopeNode) => decodeFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode));
+                    const decodeObject = ctx.runtime.named('sts:decode', 'object').text();
+                    const decodeMap = ctx.runtime.named('sts:decode', 'map').text();
+                    const decodeOptional = ctx.runtime.named('sts:decode', 'optional').text();
+                    const decodeLiteral = ctx.runtime.named('sts:decode', 'literal').text();
+                    const decodeUnion = ctx.runtime.named('sts:decode', 'union').text();
+                    const variantDecoders = variants.map((variant) => taggedDecodeVariantText(discriminantName, variant, decodeLiteral, decodeMap, decodeObject, decodeOptional));
+                    const unionText = foldUnionText(decodeUnion, variantDecoders);
+                    return ctx.output.stmt(ctx.quote.stmt `
+              export const ${`${typeName}Decoder`} = ${unionText};
+            `);
+                }
+            }
+            const { fields, instantiateText, typeName } = collectDecodeFields(ctx, decoded);
+            const object = ctx.runtime.named('sts:decode', 'object').text();
+            const map = ctx.runtime.named('sts:decode', 'map').text();
+            const optional = ctx.runtime.named('sts:decode', 'optional').text();
+            const shapeText = fields.length === 0 ? '{}' : `{
+            ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${optional}(${field.decoderText})` : field.decoderText}`).join(',\n')}
+          }`;
+            const projectionText = fields.length === 0 ? '{}' : `({
+            ${fields.map((field) => `${propertyKeyText(field.localName)}: ${propertyAccessText('value', field.wireName)}`).join(',\n')}
+          })`;
+            const finalProjectionText = instantiateText === null
+                ? projectionText
+                : `(${instantiateText.replace(CLASS_DECODE_VALUE_PLACEHOLDER, projectionText)})`;
+            return ctx.output.stmt(ctx.quote.stmt `
+          export const ${`${typeName}Decoder`} = ${map}(
+            ${object}(${shapeText}),
+            (value) => ${finalProjectionText},
+          );
+        `);
+        },
+        signature: DECODE_SIGNATURE,
+    };
+}
+attachDeriveFactory(decode);
+// #[macro(decl)]
+export function encode() {
+    return {
+        declarationKinds: ['class', 'interface', 'typeAlias'],
+        expansionMode: 'augment',
+        expand(ctx, decoded) {
+            if (decoded.caseName === 'typeAlias') {
+                const declaration = decoded.args.target;
+                if (!declaration.type.asObjectLiteral() && declaration.type.asUnion()) {
+                    const { discriminantName, typeName, variants } = collectTaggedDerivedVariants(ctx, declaration, 'encode', (field, ownerTypeName, scopeNode) => encodeFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode));
+                    const encodeFromEncode = ctx.runtime.named('sts:encode', 'fromEncode').text();
+                    const encodeObject = ctx.runtime.named('sts:encode', 'object').text();
+                    const encodeOptional = ctx.runtime.named('sts:encode', 'optional').text();
+                    const stringEncoder = ctx.runtime.named('sts:encode', 'stringEncoder').text();
+                    const switchCases = variants.map((variant) => {
+                        const variantType = taggedVariantTypeText(typeName, discriminantName, variant.tag);
+                        const shapeText = taggedEncodeVariantShapeText(discriminantName, variant, encodeOptional, stringEncoder);
+                        const projectionText = taggedEncodeVariantProjectionText(discriminantName, variant, `value as ${variantType}`);
+                        return `case '${variant.tag}':
+              return ${encodeObject}(${shapeText}).encode(${projectionText});`;
+                    }).join('\n');
+                    return ctx.output.stmt(ctx.quote.stmt `
+              export const ${`${typeName}Encoder`} = ${encodeFromEncode}((value: ${typeName}) => {
+                switch (${propertyAccessText('value', discriminantName)}) {
+                  ${switchCases}
+                  default:
+                    throw new Error('unreachable tagged union encoder case');
+                }
+              });
+            `);
+                }
+            }
+            const { fields, typeName } = collectEncodeFields(ctx, decoded);
+            const contramap = ctx.runtime.named('sts:encode', 'contramap').text();
+            const object = ctx.runtime.named('sts:encode', 'object').text();
+            const optional = ctx.runtime.named('sts:encode', 'optional').text();
+            const shapeText = fields.length === 0 ? '{}' : `{
+            ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${optional}(${field.encoderText})` : field.encoderText}`).join(',\n')}
+          }`;
+            const projectionText = fields.length === 0 ? '({})' : `({
+            ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${propertyAccessText('value', field.localName)}`).join(',\n')}
+          })`;
+            return ctx.output.stmt(ctx.quote.stmt `
+          export const ${`${typeName}Encoder`} = ${contramap}(
+            ${object}(${shapeText}),
+            (value: ${typeName}) => ${projectionText},
+          );
+        `);
+        },
+        signature: DECODE_SIGNATURE,
+    };
+}
+attachDeriveFactory(encode);
+// #[macro(decl)]
+export function codec() {
+    return {
+        declarationKinds: ['class', 'interface', 'typeAlias'],
+        expansionMode: 'augment',
+        expand(ctx, decoded) {
+            if (decoded.caseName === 'typeAlias') {
+                const declaration = decoded.args.target;
+                if (!declaration.type.asObjectLiteral() && declaration.type.asUnion()) {
+                    const { discriminantName, typeName, variants } = collectTaggedDerivedVariants(ctx, declaration, 'codec', (field, ownerTypeName, scopeNode) => codecFieldFromReflectedShape(ctx, field, ownerTypeName, scopeNode));
+                    const createCodec = ctx.runtime.named('sts:codec', 'codec').text();
+                    const decodeObject = ctx.runtime.named('sts:decode', 'object').text();
+                    const decodeMap = ctx.runtime.named('sts:decode', 'map').text();
+                    const decodeOptional = ctx.runtime.named('sts:decode', 'optional').text();
+                    const decodeLiteral = ctx.runtime.named('sts:decode', 'literal').text();
+                    const decodeUnion = ctx.runtime.named('sts:decode', 'union').text();
+                    const encodeFromEncode = ctx.runtime.named('sts:encode', 'fromEncode').text();
+                    const encodeObject = ctx.runtime.named('sts:encode', 'object').text();
+                    const encodeOptional = ctx.runtime.named('sts:encode', 'optional').text();
+                    const stringEncoder = ctx.runtime.named('sts:encode', 'stringEncoder').text();
+                    const variantDecoders = variants.map((variant) => taggedCodecDecodeVariantText(discriminantName, variant, decodeLiteral, decodeMap, decodeObject, decodeOptional));
+                    const unionText = foldUnionText(decodeUnion, variantDecoders);
+                    const switchCases = variants.map((variant) => {
+                        const variantType = taggedVariantTypeText(typeName, discriminantName, variant.tag);
+                        const shapeText = taggedCodecEncodeVariantShapeText(discriminantName, variant, encodeOptional, stringEncoder);
+                        const projectionText = taggedCodecEncodeVariantProjectionText(discriminantName, variant, `value as ${variantType}`);
+                        return `case '${variant.tag}':
+              return ${encodeObject}(${shapeText}).encode(${projectionText});`;
+                    }).join('\n');
+                    return ctx.output.stmt(ctx.quote.stmt `
+              export const ${`${typeName}Codec`} = ${createCodec}(
+                ${unionText},
+                ${encodeFromEncode}((value: ${typeName}) => {
+                  switch (${propertyAccessText('value', discriminantName)}) {
+                    ${switchCases}
+                    default:
+                      throw new Error('unreachable tagged union codec case');
+                  }
+                }),
+              );
+            `);
+                }
+            }
+            const { fields, instantiateText, typeName } = collectCodecFields(ctx, decoded);
+            const codec = ctx.runtime.named('sts:codec', 'codec').text();
+            const decodeObject = ctx.runtime.named('sts:decode', 'object').text();
+            const decodeMap = ctx.runtime.named('sts:decode', 'map').text();
+            const decodeOptional = ctx.runtime.named('sts:decode', 'optional').text();
+            const encodeContramap = ctx.runtime.named('sts:encode', 'contramap').text();
+            const encodeObject = ctx.runtime.named('sts:encode', 'object').text();
+            const encodeOptional = ctx.runtime.named('sts:encode', 'optional').text();
+            const decodeShapeText = fields.length === 0 ? '{}' : `{
+            ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${decodeOptional}(${field.decodeText})` : field.decodeText}`).join(',\n')}
+          }`;
+            const decodeProjectionText = fields.length === 0 ? '{}' : `({
+            ${fields.map((field) => `${propertyKeyText(field.localName)}: ${propertyAccessText('value', field.wireName)}`).join(',\n')}
+          })`;
+            const finalDecodeProjectionText = instantiateText === null
+                ? decodeProjectionText
+                : `(${instantiateText.replace(CLASS_DECODE_VALUE_PLACEHOLDER, decodeProjectionText)})`;
+            const encodeShapeText = fields.length === 0 ? '{}' : `{
+            ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${field.optional ? `${encodeOptional}(${field.encodeText})` : field.encodeText}`).join(',\n')}
+          }`;
+            const encodeProjectionText = fields.length === 0 ? '({})' : `({
+            ${fields.map((field) => `${propertyKeyText(field.wireName)}: ${propertyAccessText('value', field.localName)}`).join(',\n')}
+          })`;
+            return ctx.output.stmt(ctx.quote.stmt `
+          export const ${`${typeName}Codec`} = ${codec}(
+            ${decodeMap}(
+              ${decodeObject}(${decodeShapeText}),
+              (value) => ${finalDecodeProjectionText},
+            ),
+            ${encodeContramap}(
+              ${encodeObject}(${encodeShapeText}),
+              (value: ${typeName}) => ${encodeProjectionText},
+            ),
+          );
+        `);
+        },
+        signature: DECODE_SIGNATURE,
+    };
+}
+attachDeriveFactory(codec);