AST again (rebase) #1429

anotherjesse · 2025-07-17T14:33:03Z

No description provided.

cubic-dev-ai

cubic found 15 issues across 133 files. Review them in cubic.dev

_{React with 👍 or 👎 to teach cubic. Tag @cubic-dev-ai to give specific feedback.}

cubic-dev-ai · 2025-07-17T14:38:38Z

packages/js-runtime/test/fixtures/opaque-refs/complex-function-with-ternary.expected.ts

commontools_1 is used without being imported or defined, which will cause a ReferenceError at runtime. Use the imported derive function directly or ensure commontools_1 is properly imported.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/fixtures/opaque-refs/complex-function-with-ternary.expected.ts at line 8: <comment>commontools_1 is used without being imported or defined, which will cause a ReferenceError at runtime. Use the imported derive function directly or ensure commontools_1 is properly imported.</comment> <file context> @@ -0,0 +1,8 @@ +/// <cts-enable /> +import { cell, derive } from "commontools"; +const price = cell(100); +const discount = cell(20); +const pitance = cell(5); +const prime = cell(true); +// Function with complex expression including ternary +const total = commontools_1.derive({ price, prime, discount, pitance }, ({ price: _v1, prime: _v2, discount: _v3, pitance: _v4 }) => _v1 - (_v2 ? _v3 : _v4)); \ No newline at end of file </file context>

cubic-dev-ai · 2025-07-17T14:38:38Z

packages/js-runtime/typescript/transformer/schema.ts

JSON Schema has no "undefined" primitive type; emitting this value produces an invalid schema and will fail validation tools.

Prompt for AI agents

Address the following comment on packages/js-runtime/typescript/transformer/schema.ts at line 190: <comment>JSON Schema has no "undefined" primitive type; emitting this value produces an invalid schema and will fail validation tools.</comment> <file context> @@ -0,0 +1,675 @@ +import ts from "typescript"; +import { addCommonToolsImport, hasCommonToolsImport, removeCommonToolsImport } from "./imports.ts"; +import { createDebugger, TransformerOptions } from "./debug.ts"; + +/** + * Transformer that converts TypeScript types to JSONSchema objects. + * Transforms `toSchema<T>()` calls into JSONSchema literals. + */ +export function createSchemaTransformer( + program: ts.Program, + options: TransformerOptions = {}, +): ts.TransformerFactory<ts.SourceFile> { + const debugLogger = createDebugger('SchemaTransformer', options); + const checker = program.getTypeChecker(); + + return (context: ts.TransformationContext) => { + return (sourceFile: ts.SourceFile) => { + // Check if this file has the /// <cts-enable /> directive + const hasCtsEnableDirective = (): boolean => { + const text = sourceFile.getFullText(); + const tripleSlashDirectives = ts.getLeadingCommentRanges(text, 0) || []; + + for (const comment of tripleSlashDirectives) { + const commentText = text.substring(comment.pos, comment.end); + if (/^\/\/\/\s*<cts-enable\s*\/>/m.test(commentText)) { + return true; + } + } + return false; + }; + + // Skip transformation if directive is not present + if (!hasCtsEnableDirective()) { + return sourceFile; + } + + let needsJSONSchemaImport = false; + let hasTransformedToSchema = false; + + const visit: ts.Visitor = (node) => { + // Look for toSchema<T>() calls + if ( + ts.isCallExpression(node) && + ts.isIdentifier(node.expression) && + node.expression.text === "toSchema" && + node.typeArguments && + node.typeArguments.length === 1 + ) { + const typeArg = node.typeArguments[0]; + const type = checker.getTypeFromTypeNode(typeArg); + + if (debugLogger.isEnabled() && typeArg) { + debugLogger.log( + `Found toSchema<${typeArg.getText()}>() call` + ); + } + + // Extract options from the call arguments + const options = node.arguments[0]; + let optionsObj: any = {}; + if (options && ts.isObjectLiteralExpression(options)) { + optionsObj = evaluateObjectLiteral(options, checker); + } + + // Generate JSONSchema from the type + const schema = typeToJsonSchema(type, checker, typeArg); + + // Merge with options + const finalSchema = { ...schema, ...optionsObj }; + + // Create the AST for the schema object + const schemaAst = createSchemaAst(finalSchema, context.factory); + + // Add type assertion: as const satisfies JSONSchema + const constAssertion = context.factory.createAsExpression( + schemaAst, + context.factory.createTypeReferenceNode( + context.factory.createIdentifier("const"), + undefined, + ), + ); + + const satisfiesExpression = context.factory.createSatisfiesExpression( + constAssertion, + context.factory.createTypeReferenceNode( + context.factory.createIdentifier("JSONSchema"), + undefined, + ), + ); + + // Mark that we need JSONSchema import + if (!hasCommonToolsImport(sourceFile, "JSONSchema")) { + needsJSONSchemaImport = true; + } + + hasTransformedToSchema = true; + return satisfiesExpression; + } + + return ts.visitEachChild(node, visit, context); + }; + + let result = ts.visitNode(sourceFile, visit) as ts.SourceFile; + + // Add JSONSchema import if needed + if (needsJSONSchemaImport) { + result = addCommonToolsImport(result, context.factory, "JSONSchema"); + } + + // Log for debugging the handler-object-literal case + if (sourceFile.fileName.includes("handler-object-literal")) { + console.log(`[SchemaTransformer] Processing ${sourceFile.fileName}`); + console.log(` - hasTransformedToSchema: ${hasTransformedToSchema}`); + console.log(` - hasCommonToolsImport(result, "toSchema"): ${hasCommonToolsImport(result, "toSchema")}`); + } + + // Remove toSchema import if we transformed all its uses + if (hasCommonToolsImport(result, "toSchema")) { + // Check if toSchema is still used anywhere in the transformed code + const stillUsesToSchema = containsToSchemaReference(result); + + if (debugLogger.isEnabled()) { + debugLogger.log(`Checking toSchema import removal:`); + debugLogger.log(` - hasCommonToolsImport(toSchema): true`); + debugLogger.log(` - stillUsesToSchema: ${stillUsesToSchema}`); + } + + if (!stillUsesToSchema) { + if (debugLogger.isEnabled()) { + debugLogger.log(`Removing toSchema import`); + } + result = removeCommonToolsImport(result, context.factory, "toSchema"); + } + } + + return result; + }; + }; +} + +/** + * Convert a TypeScript type to JSONSchema + */ +function typeToJsonSchema( + type: ts.Type, + checker: ts.TypeChecker, + typeNode?: ts.TypeNode, +): any { + + // If we have a type node, check if it's a type reference to Default<T, V> + if (typeNode && ts.isTypeReferenceNode(typeNode)) { + const typeName = typeNode.typeName; + if (ts.isIdentifier(typeName) && typeName.text === "Default") { + if (typeNode.typeArguments && typeNode.typeArguments.length >= 2) { + const innerTypeNode = typeNode.typeArguments[0]; + const defaultValueNode = typeNode.typeArguments[1]; + + // Get the inner type + const innerType = checker.getTypeFromTypeNode(innerTypeNode); + const schema = typeToJsonSchema(innerType, checker, innerTypeNode); + + // Extract the default value from the type node + const defaultValue = extractValueFromTypeNode(defaultValueNode, checker); + if (defaultValue !== undefined) { + schema.default = defaultValue; + } + + return schema; + } + } + } + // Handle primitive types + if (type.flags & ts.TypeFlags.String) { + return { type: "string" }; + } + if (type.flags & ts.TypeFlags.Number) { + return { type: "number" }; + } + if (type.flags & ts.TypeFlags.Boolean) { + return { type: "boolean" }; + } + if (type.flags & ts.TypeFlags.BooleanLiteral) { + // Handle boolean literals (true/false) as boolean type + return { type: "boolean" }; + } + if (type.flags & ts.TypeFlags.Null) { + return { type: "null" }; + } + if (type.flags & ts.TypeFlags.Undefined) { + return { type: "undefined" }; + } + + // Handle arrays + if (type.symbol && type.symbol.name === "Array") { + const typeRef = type as ts.TypeReference; + if (typeRef.typeArguments && typeRef.typeArguments.length > 0) { + return { + type: "array", + items: typeToJsonSchema(typeRef.typeArguments[0], checker), + }; + } + return { type: "array" }; + } + + // Also check if it's an array type using the checker + const typeString = checker.typeToString(type); + if (typeString.endsWith("[]")) { + // Extract the element type + const elementTypeString = typeString.slice(0, -2); + // This is a simplified approach - in a real implementation we'd need to get the actual element type + if (elementTypeString === "string") { + return { type: "array", items: { type: "string" } }; + } else if (elementTypeString === "number") { + return { type: "array", items: { type: "number" } }; + } else if (elementTypeString === "boolean") { + return { type: "array", items: { type: "boolean" } }; + } + return { type: "array" }; + } + + // Handle Date + const symbol = type.getSymbol(); + if (symbol && symbol.name === "Date") { + return { type: "string", format: "date-time" }; + } + + // Check if this is a type reference (e.g., Default<T, V>) + if ((type as any).target) { + const typeRef = type as ts.TypeReference; + const target = (typeRef as any).target; + + // Check if it's Default type by checking the symbol name + if (target.symbol && target.symbol.name === "Default") { + // This is a generic type Default<T, V> + if (typeRef.typeArguments && typeRef.typeArguments.length >= 2) { + const innerType = typeRef.typeArguments[0]; + const defaultValueType = typeRef.typeArguments[1]; + + // Get the schema for the inner type + const schema = typeToJsonSchema(innerType, checker, typeNode); + + // Try to extract the literal value from the default value type + if (defaultValueType.isNumberLiteral && defaultValueType.isNumberLiteral()) { + // @ts-ignore - accessing value property + schema.default = (defaultValueType as any).value; + } else if (defaultValueType.isStringLiteral && defaultValueType.isStringLiteral()) { + // @ts-ignore - accessing value property + schema.default = (defaultValueType as any).value; + } else if ((defaultValueType as any).intrinsicName === "true") { + schema.default = true; + } else if ((defaultValueType as any).intrinsicName === "false") { + schema.default = false; + } else if (defaultValueType.flags & ts.TypeFlags.NumberLiteral) { + // @ts-ignore - accessing value property + schema.default = (defaultValueType as any).value; + } else if (defaultValueType.flags & ts.TypeFlags.StringLiteral) { + // @ts-ignore - accessing value property + schema.default = (defaultValueType as any).value; + } else if (defaultValueType.flags & ts.TypeFlags.BooleanLiteral) { + // @ts-ignore - accessing intrinsicName property + schema.default = (defaultValueType as any).intrinsicName === "true"; + } + + return schema; + } + } + } + + // Handle Default<T, V> type via symbol check (fallback) + if (symbol && symbol.name === "Default") { + // This is a generic type Default<T, V> + const typeRef = type as ts.TypeReference; + if (typeRef.typeArguments && typeRef.typeArguments.length >= 2) { + const innerType = typeRef.typeArguments[0]; + const defaultValueType = typeRef.typeArguments[1]; + + // Get the schema for the inner type + const schema = typeToJsonSchema(innerType, checker, typeNode); + + // Try to extract the literal value from the default value type + if (defaultValueType.isNumberLiteral && defaultValueType.isNumberLiteral()) { + // @ts-ignore - accessing value property + schema.default = (defaultValueType as any).value; + } else if (defaultValueType.isStringLiteral && defaultValueType.isStringLiteral()) { + // @ts-ignore - accessing value property + schema.default = (defaultValueType as any).value; + } else if ((defaultValueType as any).intrinsicName === "true") { + schema.default = true; + } else if ((defaultValueType as any).intrinsicName === "false") { + schema.default = false; + } else if (defaultValueType.flags & ts.TypeFlags.NumberLiteral) { + // @ts-ignore - accessing value property + schema.default = (defaultValueType as any).value; + } else if (defaultValueType.flags & ts.TypeFlags.StringLiteral) { + // @ts-ignore - accessing value property + schema.default = (defaultValueType as any).value; + } else if (defaultValueType.flags & ts.TypeFlags.BooleanLiteral) { + // @ts-ignore - accessing intrinsicName property + schema.default = (defaultValueType as any).intrinsicName === "true"; + } + + return schema; + } + // If we can't extract type arguments, return a permissive schema + return { type: "object", additionalProperties: true }; + } + + // Handle object types (interfaces, type literals) + if (type.flags & ts.TypeFlags.Object) { + const properties: any = {}; + const required: string[] = []; + + // Get all properties (including inherited ones) + const props = type.getProperties(); + for (const prop of props) { + const propName = prop.getName(); + + // Skip symbol properties + if (propName.startsWith("__")) continue; + + const propType = checker.getTypeOfSymbolAtLocation( + prop, + prop.valueDeclaration || typeNode || prop.declarations?.[0]!, + ); + + // Check if property is optional + const isOptional = prop.flags & ts.SymbolFlags.Optional; + if (!isOptional) { + required.push(propName); + } + + // Check if the property has a type node we can analyze directly + const propDecl = prop.valueDeclaration; + let propTypeNode: ts.TypeNode | undefined; + if (propDecl && ts.isPropertySignature(propDecl) && propDecl.type) { + propTypeNode = propDecl.type; + } + + // Check if the property type is Cell<T>, Stream<T>, or Default<T, V> + const propTypeString = checker.typeToString(propType); + let actualPropType = propType; + let isCell = false; + let isStream = false; + + // Check if we have a Cell<T> or Stream<T> type node + let innerTypeNode: ts.TypeNode | undefined; + + // Check if this is a Cell<T> type + if (propTypeString.startsWith("Cell<") && propTypeString.endsWith(">")) { + isCell = true; + // Extract the inner type + if (propType.symbol && propType.symbol.getName() === "Cell") { + // This is a type alias, get its type arguments + const typeRef = propType as ts.TypeReference; + if (typeRef.typeArguments && typeRef.typeArguments.length > 0) { + actualPropType = typeRef.typeArguments[0]; + } + } else if ((propType as any).resolvedTypeArguments) { + // Handle resolved type arguments + const resolvedArgs = (propType as any).resolvedTypeArguments; + if (resolvedArgs.length > 0) { + actualPropType = resolvedArgs[0]; + } + } + // If we have a type node, extract the inner type node + if (propTypeNode && ts.isTypeReferenceNode(propTypeNode) && + propTypeNode.typeArguments && propTypeNode.typeArguments.length > 0) { + innerTypeNode = propTypeNode.typeArguments[0]; + } + } // Check if this is a Stream<T> type + else if ( + propTypeString.startsWith("Stream<") && propTypeString.endsWith(">") + ) { + isStream = true; + // Extract the inner type + const typeRef = propType as ts.TypeReference; + if (typeRef.typeArguments && typeRef.typeArguments.length > 0) { + actualPropType = typeRef.typeArguments[0]; + } + // If we have a type node, extract the inner type node + if (propTypeNode && ts.isTypeReferenceNode(propTypeNode) && + propTypeNode.typeArguments && propTypeNode.typeArguments.length > 0) { + innerTypeNode = propTypeNode.typeArguments[0]; + } + } + + // Get property schema for the actual type (unwrapped if it was Cell/Stream) + const propSchema = typeToJsonSchema(actualPropType, checker, innerTypeNode || propTypeNode); + + // Add asCell/asStream flags + if (isCell) { + propSchema.asCell = true; + } + if (isStream) { + propSchema.asStream = true; + } + + properties[propName] = propSchema; + } + + const schema: any = { + type: "object", + properties, + }; + + if (required.length > 0) { + schema.required = required; + } + + return schema; + } + + // Handle union types + if (type.isUnion()) { + const unionTypes = (type as ts.UnionType).types; + // Check if it's a nullable type (T | undefined) + const nonNullTypes = unionTypes.filter((t) => + !(t.flags & ts.TypeFlags.Undefined) + ); + + // Special handling for boolean | undefined (which appears as false | true | undefined) + if (unionTypes.length === 3 && + unionTypes.filter(t => t.flags & ts.TypeFlags.BooleanLiteral).length === 2 && + unionTypes.filter(t => t.flags & ts.TypeFlags.Undefined).length === 1) { + // This is boolean | undefined, return boolean schema + return { type: "boolean" }; + } + + if (nonNullTypes.length === 1 && unionTypes.length === 2) { + // This is an optional type, just return the non-null type schema + return typeToJsonSchema(nonNullTypes[0], checker, typeNode); + } + // Otherwise, use oneOf + return { + oneOf: unionTypes.map((t) => typeToJsonSchema(t, checker, typeNode)), + }; + } + + // Default fallback - for "any" type, use a permissive schema + return { type: "object", additionalProperties: true }; +} + +/** + * Create AST for a schema object + */ +function createSchemaAst(schema: any, factory: ts.NodeFactory): ts.Expression { + if (schema === null) { + return factory.createNull(); + } + + if (typeof schema === "string") { + return factory.createStringLiteral(schema); + } + + if (typeof schema === "number") { + return factory.createNumericLiteral(schema); + } + + if (typeof schema === "boolean") { + return schema ? factory.createTrue() : factory.createFalse(); + } + + if (Array.isArray(schema)) { + return factory.createArrayLiteralExpression( + schema.map((item) => createSchemaAst(item, factory)), + ); + } + + if (typeof schema === "object") { + const properties: ts.PropertyAssignment[] = []; + + for (const [key, value] of Object.entries(schema)) { + // Handle nested schemas that might be references + if (key === "asStream" && value === true && schema.type) { + // For asStream properties, we need to spread the base schema + const baseSchema = { ...schema }; + delete baseSchema.asStream; + + return factory.createObjectLiteralExpression([ + factory.createSpreadAssignment(createSchemaAst(baseSchema, factory)), + factory.createPropertyAssignment( + factory.createIdentifier("asStream"), + factory.createTrue(), + ), + ]); + } + + properties.push( + factory.createPropertyAssignment( + factory.createIdentifier(key), + createSchemaAst(value, factory), + ), + ); + } + + return factory.createObjectLiteralExpression(properties, true); + } + + return factory.createIdentifier("undefined"); +} + +/** + * Evaluate an object literal to extract its values + */ +function evaluateObjectLiteral( + node: ts.ObjectLiteralExpression, + checker: ts.TypeChecker, +): any { + const result: any = {}; + + for (const prop of node.properties) { + if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) { + const key = prop.name.text; + const value = evaluateExpression(prop.initializer, checker); + if (value !== undefined) { + result[key] = value; + } + } + } + + return result; +} + +// Helper function to evaluate any expression to a literal value +function evaluateExpression( + node: ts.Expression, + checker: ts.TypeChecker, +): any { + if (ts.isStringLiteral(node)) { + return node.text; + } else if (ts.isNumericLiteral(node)) { + return Number(node.text); + } else if (node.kind === ts.SyntaxKind.TrueKeyword) { + return true; + } else if (node.kind === ts.SyntaxKind.FalseKeyword) { + return false; + } else if (node.kind === ts.SyntaxKind.NullKeyword) { + return null; + } else if (node.kind === ts.SyntaxKind.UndefinedKeyword) { + return undefined; + } else if (ts.isObjectLiteralExpression(node)) { + return evaluateObjectLiteral(node, checker); + } else if (ts.isArrayLiteralExpression(node)) { + const values: any[] = []; + for (const elem of node.elements) { + const value = evaluateExpression(elem, checker); + // Keep undefined values in arrays + values.push(value); + } + return values; + } + // Return a special marker for unknown expressions + return undefined; +} + +// Helper function to extract values from type nodes (for Default<T, V>) +function extractValueFromTypeNode( + node: ts.TypeNode, + checker: ts.TypeChecker, +): any { + // Handle literal type nodes + if (ts.isLiteralTypeNode(node)) { + const literal = node.literal; + if (ts.isStringLiteral(literal)) { + return literal.text; + } else if (ts.isNumericLiteral(literal)) { + return Number(literal.text); + } else if (literal.kind === ts.SyntaxKind.TrueKeyword) { + return true; + } else if (literal.kind === ts.SyntaxKind.FalseKeyword) { + return false; + } else if (literal.kind === ts.SyntaxKind.NullKeyword) { + return null; + } + } + + // Handle tuple types (array literals in type position) + if (ts.isTupleTypeNode(node)) { + const values: any[] = []; + for (const elem of node.elements) { + const value = extractValueFromTypeNode(elem, checker); + values.push(value); + } + return values; + } + + // Handle type literals (object literals in type position) + if (ts.isTypeLiteralNode(node)) { + const obj: any = {}; + for (const member of node.members) { + if (ts.isPropertySignature(member) && member.name && ts.isIdentifier(member.name)) { + const key = member.name.text; + if (member.type) { + const value = extractValueFromTypeNode(member.type, checker); + if (value !== undefined) { + obj[key] = value; + } + } + } + } + return obj; + } + + // Handle array type with literal elements + if (ts.isArrayTypeNode(node)) { + // For array types like string[], we can't extract a default value + return undefined; + } + + // Handle union types (for nullable types) + if (ts.isUnionTypeNode(node)) { + // Check if one of the types is null + for (const type of node.types) { + if (type.kind === ts.SyntaxKind.NullKeyword) { + return null; + } + if (type.kind === ts.SyntaxKind.UndefinedKeyword) { + return undefined; + } + } + } + + // Handle direct null/undefined keywords + if (node.kind === ts.SyntaxKind.NullKeyword) { + return null; + } + if (node.kind === ts.SyntaxKind.UndefinedKeyword) { + return undefined; + } + + return undefined; +} + +/** + * Check if the source file contains any remaining references to toSchema + * after transformation. + */ +function containsToSchemaReference(sourceFile: ts.SourceFile): boolean { + let found = false; + let count = 0; + + const visit: ts.Visitor = (node) => { + if (found) return node; + + // Check for toSchema identifier references + if (ts.isIdentifier(node) && node.text === "toSchema") { + count++; + // Make sure it's not part of an import declaration + let parent = node.parent; + while (parent) { + if (ts.isImportDeclaration(parent)) { + // This is part of an import, not a usage + return node; + } + parent = parent.parent; + } + // Found a usage of toSchema outside of imports + found = true; + return node; + } + + return ts.visitEachChild(node, visit, undefined); + }; + + ts.visitNode(sourceFile, visit); + + // Debug log for handler-object-literal + if (sourceFile.fileName.includes("handler-object-literal")) { + console.log(`[containsToSchemaReference] ${sourceFile.fileName}:`); + console.log(` - Total toSchema identifiers found: ${count}`); + console.log(` - Found non-import usage: ${found}`); + } + + return found; +} </file context>

cubic-dev-ai · 2025-07-17T14:38:38Z

packages/js-runtime/test/fixtures/opaque-refs/multiple-refs-operations.expected.ts

'commontools_1' is used without being imported or defined, which will cause a ReferenceError at runtime. Use the imported 'derive' function instead.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/fixtures/opaque-refs/multiple-refs-operations.expected.ts at line 33: <comment>'commontools_1' is used without being imported or defined, which will cause a ReferenceError at runtime. Use the imported 'derive' function instead.</comment> <file context> @@ -0,0 +1,33 @@ +/// <cts-enable /> +import { cell, derive } from "commontools"; +// Basic string concatenation with multiple OpaqueRefs +const firstName = cell("John"); +const lastName = cell("Doe"); +const fullName = commontools_1.derive({ firstName, lastName }, ({ firstName: _v1, lastName: _v2 }) => _v1 + " " + _v2); +// String template with multiple OpaqueRefs +const greeting = commontools_1.derive({ firstName, lastName }, ({ firstName: _v1, lastName: _v2 }) => `Hello, ${_v1} ${_v2}!`); +// Multiple OpaqueRefs in different operations +const x = cell(10); +const y = cell(20); +const z = cell(30); +// Arithmetic with multiple refs +const sum = commontools_1.derive({ x, y, z }, ({ x: _v1, y: _v2, z: _v3 }) => _v1 + _v2 + _v3); +const product = commontools_1.derive({ x, y, z }, ({ x: _v1, y: _v2, z: _v3 }) => _v1 * _v2 * _v3); +const complex = commontools_1.derive({ x, y, z }, ({ x: _v1, y: _v2, z: _v3 }) => (_v1 + _v2) * _v3 - (_v1 * _v2)); +// Boolean operations with multiple refs +const allPositive = commontools_1.derive({ x, y, z }, ({ x: _v1, y: _v2, z: _v3 }) => _v1 > 0 && _v2 > 0 && _v3 > 0); +const anyNegative = commontools_1.derive({ x, y, z }, ({ x: _v1, y: _v2, z: _v3 }) => _v1 < 0 || _v2 < 0 || _v3 < 0); +// Mixed operations +const description = commontools_1.derive({ x, y, z }, ({ x: _v1, y: _v2, z: _v3 }) => `Sum: ${_v1 + _v2 + _v3}, Product: ${_v1 * _v2 * _v3}`); +// TODO(ja): Array operations with OpaqueRef arrays +// const items = cell([1, 2, 3]); +// const doubled = items.map(x => x * 2); // Not yet supported - needs different transformation approach +// const filtered = items.filter(x => x > 2); // Not yet supported - needs different transformation approach +// TODO(ja): Async operations with OpaqueRef +// const url = cell("https://api.example.com/data"); +// const response = await fetch(url); // Not yet supported - async/await with OpaqueRef needs special handling +// Nested object property access with multiple refs +const user1 = cell({ name: "Alice", age: 30 }); +const user2 = cell({ name: "Bob", age: 25 }); +const combinedAge = commontools_1.derive({ user1_age: user1.age, user2_age: user2.age }, ({ user1_age: _v1, user2_age: _v2 }) => _v1 + _v2); +const nameComparison = commontools_1.derive({ user1_name: user1.name, user2_name: user2.name }, ({ user1_name: _v1, user2_name: _v2 }) => _v1 === _v2); \ No newline at end of file </file context>

cubic-dev-ai · 2025-07-17T14:38:38Z

packages/js-runtime/test/fixtures/opaque-refs/ternary-with-cell.expected.ts

commontools_1 is not imported or defined in this file, which will cause a ReferenceError at runtime. Use the imported ifElse function directly or import commontools_1 if needed.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/fixtures/opaque-refs/ternary-with-cell.expected.ts at line 4: <comment>commontools_1 is not imported or defined in this file, which will cause a ReferenceError at runtime. Use the imported ifElse function directly or import commontools_1 if needed.</comment> <file context> @@ -0,0 +1,4 @@ +/// <cts-enable /> +import { OpaqueRef, ifElse, cell } from "commontools"; +const isActive = cell<boolean>(false); +const result = commontools_1.ifElse(isActive, "active", "inactive"); \ No newline at end of file </file context>

cubic-dev-ai · 2025-07-17T14:38:38Z

packages/js-runtime/test/fixtures/ast-transform/counter-recipe.input.tsx

increment is a handler function and should be passed as a reference or called with the correct arguments. Calling increment({ value: state.value }) here will immediately invoke the handler during render, not on click.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/fixtures/ast-transform/counter-recipe.input.tsx at line 29: <comment>increment is a handler function and should be passed as a reference or called with the correct arguments. Calling increment({ value: state.value }) here will immediately invoke the handler during render, not on click.</comment> <file context> @@ -0,0 +1,34 @@ +/// <cts-enable /> +import { Cell, Default, h, handler, NAME, recipe, str, UI } from "commontools"; + +interface CounterState { + value: Cell<number>; +} + +interface RecipeState { + value: Default<number, 0>; +} + +const increment = handler<unknown, CounterState>((e, state) => { + state.value.set(state.value.get() + 1); +}); + +const decrement = handler((_, state: { value: Cell<number> }) => { + state.value.set(state.value.get() - 1); +}); + +export default recipe<RecipeState>("Counter", (state) => { + return { + [NAME]: str`Simple counter: ${state.value}`, + [UI]: ( + <div> + <ct-button onClick={decrement(state)}>-</ct-button> + <ul> + <li>next number: {state.value + 1}</li> + </ul> + <ct-button onClick={increment({ value: state.value })}>+</ct-button> + </div> + ), + value: state.value, + }; +}); </file context>

Suggested change

<ct-button onClick={increment({ value: state.value })}>+</ct-button>

<ct-button onClick={() => increment({ value: state.value })}>+</ct-button>

cubic-dev-ai · 2025-07-17T14:38:39Z

packages/js-runtime/test/fixtures/jsx-expressions/complex-expressions.expected.tsx

commontools_1 is used but not imported or defined in this file, which will cause a ReferenceError at runtime.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/fixtures/jsx-expressions/complex-expressions.expected.tsx at line 6: <comment>commontools_1 is used but not imported or defined in this file, which will cause a ReferenceError at runtime.</comment> <file context> @@ -0,0 +1,8 @@ +/// <cts-enable /> +import { OpaqueRef, derive, h } from "commontools"; +const price: OpaqueRef<number> = {} as any; +const element = (<div> + <p>Price: {price}</p> + <p>With tax: {commontools_1.derive(price, _v1 => _v1 * 1.1)}</p> + <p>Discount: {commontools_1.derive(price, _v1 => _v1 - 10)}</p> + </div>); \ No newline at end of file </file context>

cubic-dev-ai · 2025-07-17T14:38:39Z

packages/js-runtime/test/test-utils.ts

TransformationResult is not disposed; failing to call result.dispose() leaks AST nodes and symbols, which can grow memory when many tests run.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/test-utils.ts at line 191: <comment>TransformationResult is not disposed; failing to call result.dispose() leaks AST nodes and symbols, which can grow memory when many tests run.</comment> <file context> @@ -0,0 +1,273 @@ +import ts from "typescript"; +import { + createOpaqueRefTransformer, + createSchemaTransformer, +} from "../typescript/transformer/mod.ts"; +import { getTypeScriptEnvironmentTypes } from "../mod.ts"; +import { join } from "@std/path"; +import { StaticCache } from "@commontools/static"; + +// Cache environment types +let envTypesCache: Record<string, string> | undefined; + +/** + * Test utility for transforming TypeScript source code with the OpaqueRef transformer. + */ +export async function transformSource( + source: string, + options: { + mode?: "transform" | "error"; + types?: Record<string, string>; + logger?: (message: string) => void; + applySchemaTransformer?: boolean; + } = {}, +): Promise<string> { + const { + mode = "transform", + types = {}, + logger, + applySchemaTransformer = false, + } = options; + + // Get environment types if not cached + if (!envTypesCache) { + const cache = new StaticCache(); + envTypesCache = await getTypeScriptEnvironmentTypes(cache); + } + + // Create a minimal program for testing + const fileName = "/test.tsx"; + const compilerOptions: ts.CompilerOptions = { + target: ts.ScriptTarget.ES2020, + module: ts.ModuleKind.CommonJS, + jsx: ts.JsxEmit.React, + jsxFactory: "h", + strict: true, + }; + + // Combine all types + const allTypes = { ...envTypesCache, ...types }; + + // Create a custom compiler host + const host: ts.CompilerHost = { + getSourceFile: (name) => { + if (name === fileName) { + return ts.createSourceFile(name, source, compilerOptions.target!, true); + } + + // Check for lib.d.ts -> map to es2023 + if (name === "lib.d.ts" || name.endsWith("/lib.d.ts")) { + return ts.createSourceFile( + name, + allTypes.es2023 || "", + compilerOptions.target!, + true, + ); + } + + // Handle type files + if (allTypes[name]) { + return ts.createSourceFile( + name, + allTypes[name], + compilerOptions.target!, + true, + ); + } + // Check for commontools.d.ts without path + const baseName = name.split("/").pop(); + if (baseName && allTypes[baseName]) { + return ts.createSourceFile( + name, + allTypes[baseName], + compilerOptions.target!, + true, + ); + } + return undefined; + }, + writeFile: () => {}, + getCurrentDirectory: () => "/", + getDirectories: () => [], + fileExists: (name) => { + if (name === fileName) return true; + if (name === "lib.d.ts" || name.endsWith("/lib.d.ts")) return true; + if (allTypes[name]) return true; + const baseName = name.split("/").pop(); + if (baseName && allTypes[baseName]) return true; + return false; + }, + readFile: (name) => { + if (name === fileName) return source; + if (name === "lib.d.ts" || name.endsWith("/lib.d.ts")) { + return allTypes.es2023; + } + if (allTypes[name]) return allTypes[name]; + const baseName = name.split("/").pop(); + if (baseName && allTypes[baseName]) return allTypes[baseName]; + return undefined; + }, + getCanonicalFileName: (name) => name, + useCaseSensitiveFileNames: () => true, + getNewLine: () => "\n", + getDefaultLibFileName: () => "lib.d.ts", + resolveModuleNames: (moduleNames, containingFile) => { + return moduleNames.map((name) => { + if (name === "commontools" && types["commontools.d.ts"]) { + return { + resolvedFileName: "commontools.d.ts", + extension: ts.Extension.Dts, + isExternalLibraryImport: false, + }; + } + if (name === "@commontools/common" && types["commontools.d.ts"]) { + return { + resolvedFileName: "commontools.d.ts", + extension: ts.Extension.Dts, + isExternalLibraryImport: false, + }; + } + return undefined; + }); + }, + resolveTypeReferenceDirectives: ( + typeDirectiveNames, + containingFile, + redirectedReference, + options, + ) => { + return typeDirectiveNames.map((directive) => { + const name = typeof directive === "string" + ? directive + : directive.fileName; + if (allTypes[name]) { + return { + primary: true, + resolvedFileName: name, + extension: ts.Extension.Dts, + isExternalLibraryImport: false, + }; + } + return undefined; + }); + }, + }; + + // Create the program + const program = ts.createProgram([fileName], compilerOptions, host); + + // Check for errors when logger is provided + if (logger) { + const diagnostics = ts.getPreEmitDiagnostics(program); + if (diagnostics.length > 0) { + logger("=== TypeScript Diagnostics ==="); + diagnostics.forEach((diagnostic) => { + const message = ts.flattenDiagnosticMessageText( + diagnostic.messageText, + "\n", + ); + logger(`${diagnostic.file?.fileName || "unknown"}: ${message}`); + }); + logger("=== End Diagnostics ==="); + } + } + + // Create the transformers + const transformers: ts.TransformerFactory<ts.SourceFile>[] = []; + + // Always add OpaqueRef transformer first + transformers.push(createOpaqueRefTransformer(program, { + mode, + logger, + })); + + // Optionally add schema transformer + if (applySchemaTransformer) { + transformers.push(createSchemaTransformer(program, {})); + } + + // Transform the source file + const sourceFile = program.getSourceFile(fileName)!; + const result = ts.transform(sourceFile, transformers); + + // Print the result with 2-space indentation to match Deno style + const printer = ts.createPrinter({ + newLine: ts.NewLineKind.LineFeed, + removeComments: false, + }); + const output = printer.printFile(result.transformed[0]); + + if (logger) { + logger(`\n=== TEST TRANSFORMER OUTPUT ===\n${output}\n=== END OUTPUT ===`); + } + + return output; +} + +/** + * Test utility for checking if a transformation would occur without actually transforming. + */ +export async function checkWouldTransform( + source: string, + types: Record<string, string> = {}, +): Promise<boolean> { + try { + await transformSource(source, { mode: "error", types }); + return false; // No error means no transformation needed + } catch (e) { + return true; // Error means transformation would occur + } +} + +/** + * Load a fixture file from the fixtures directory + */ +export async function loadFixture(path: string): Promise<string> { + const fixturesDir = join(import.meta.dirname!, "fixtures"); + const fullPath = join(fixturesDir, path); + return await Deno.readTextFile(fullPath); +} + +/** + * Load multiple fixtures as a record + */ +export async function loadFixtures( + paths: string[], +): Promise<Record<string, string>> { + const fixtures: Record<string, string> = {}; + for (const path of paths) { + fixtures[path] = await loadFixture(path); + } + return fixtures; +} + +/** + * Transform a fixture file + */ +export async function transformFixture( + fixturePath: string, + options?: Parameters<typeof transformSource>[1], +): Promise<string> { + const source = await loadFixture(fixturePath); + return transformSource(source, options); +} + +/** + * Compare fixture transformations + */ +export async function compareFixtureTransformation( + inputPath: string, + expectedPath: string, + options?: Parameters<typeof transformSource>[1], +): Promise<{ actual: string; expected: string; matches: boolean }> { + const [actual, expected] = await Promise.all([ + transformFixture(inputPath, options), + loadFixture(expectedPath), + ]); + + return { + actual, + expected, + matches: actual.trim() === expected.trim(), + }; +} </file context>

cubic-dev-ai · 2025-07-17T14:38:39Z

packages/js-runtime/test/fixtures/ast-transform/recipe-array-map.input.tsx

The adder handler is invoked immediately during render instead of being passed as a callback to onClick. This causes the handler to run on every render rather than on button click.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/fixtures/ast-transform/recipe-array-map.input.tsx at line 18: <comment>The adder handler is invoked immediately during render instead of being passed as a callback to onClick. This causes the handler to run on every render rather than on button click.</comment> <file context> @@ -0,0 +1,31 @@ +/// <cts-enable /> +import { Cell, derive, h, handler, NAME, recipe, str, UI } from "commontools"; + +const adder = handler((_, state: { values: Cell<string[]> }) => { + state.values.push(Math.random().toString(36).substring(2, 15)); +}); + +export default recipe<{ values: string[] }>( + "Simple Value", + ({ values }) => { + derive(values, (values) => { + console.log("values#", values?.length); + }); + return { + [NAME]: str`Simple Value: ${values.length || 0}`, + [UI]: ( + <div> + <button type="button" onClick={adder({ values })}>Add Value</button> + <div> + {values.map((value, index) => ( + <div> + {index}: {value} + </div> + ))} + </div> + </div> + ), + values, + }; + }, +); \ No newline at end of file </file context>

Suggested change

<button type="button" onClick={adder({ values })}>Add Value</button>

<button type="button" onClick={() => adder({ values })}>Add Value</button>

cubic-dev-ai · 2025-07-17T14:38:39Z

packages/js-runtime/test/fixtures/opaque-refs/handler-with-types.input.ts

The named import "cell" is never used in this file, which will trigger the TypeScript no-unused-locals compiler error and adds unnecessary noise.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/fixtures/opaque-refs/handler-with-types.input.ts at line 2: <comment>The named import "cell" is never used in this file, which will trigger the TypeScript no-unused-locals compiler error and adds unnecessary noise.</comment> <file context> @@ -0,0 +1,88 @@ +/// <cts-enable /> +import { handler, cell, Cell } from "commontools"; + +// Test case 1: Simple handler with type parameters +interface EventType { + message: string; + count: number; +} + +interface StateType { + value: number; + items: string[]; +} + +const simpleHandler = handler<EventType, StateType>((event, state) => { + state.value = event.count; + state.items.push(event.message); +}); + +// Test case 2: Handler with Cell types +interface CellEvent { + data: string; + cellValue: Cell<number>; +} + +interface CellState { + count: Cell<number>; + messages: string[]; +} + +const cellHandler = handler<CellEvent, CellState>((event, state) => { + state.count.set(event.cellValue.get() + 1); + state.messages.push(event.data); +}); + +// Test case 3: Handler with nested types +interface NestedEvent { + user: { + name: string; + age: number; + }; + timestamp: Date; +} + +interface NestedState { + users: Array<{name: string, age: number}>; + lastUpdate: Date; +} + +const nestedHandler = handler<NestedEvent, NestedState>((event, state) => { + state.users.push(event.user); + state.lastUpdate = event.timestamp; +}); + +// Test case 4: Handler with optional and union types +interface ComplexEvent { + type: "add" | "remove"; + item?: string; + priority?: number; +} + +interface ComplexState { + items: string[]; + priorities: Map<string, number>; +} + +const complexHandler = handler<ComplexEvent, ComplexState>((event, state) => { + if (event.type === "add" && event.item) { + state.items.push(event.item); + if (event.priority) { + state.priorities.set(event.item, event.priority); + } + } +}); + +// Test case 5: Handler with generic constraints +interface GenericEvent<T> { + data: T; + id: string; +} + +interface GenericState<T> { + items: Map<string, T>; +} + +const genericHandler = handler<GenericEvent<string>, GenericState<string>>((event, state) => { + state.items.set(event.id, event.data); +}); \ No newline at end of file </file context>

cubic-dev-ai · 2025-07-17T14:38:39Z

packages/js-runtime/test/fixtures/opaque-refs/property-access.expected.ts

commontools_1 is not imported or defined in this file, which will cause a ReferenceError at runtime. Use the imported derive function directly or ensure commontools_1 is properly imported.

Prompt for AI agents

Address the following comment on packages/js-runtime/test/fixtures/opaque-refs/property-access.expected.ts at line 7: <comment>commontools_1 is not imported or defined in this file, which will cause a ReferenceError at runtime. Use the imported derive function directly or ensure commontools_1 is properly imported.</comment> <file context> @@ -0,0 +1,7 @@ +/// <cts-enable /> +import { OpaqueRef, derive } from "commontools"; +interface User { + age: number; +} +const user: OpaqueRef<User> = {} as any; +const result = commontools_1.derive(user.age, _v1 => _v1 + 1); \ No newline at end of file </file context>

{c1 + c2} or {c1 ? c1 : c2} should work

The tests were failing because TypeScript couldn't resolve types properly, treating OpaqueRef types as 'any'. Fixed by: - Loading TypeScript environment types (es2023.d.ts) in test utilities - Making transformSource and checkWouldTransform async - Updating all test functions to handle async operations - Properly mapping lib.d.ts requests to es2023 types This ensures proper type resolution so the OpaqueRef transformer can correctly identify and transform OpaqueRef expressions. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

The transformer now recursively visits whenTrue and whenFalse branches before creating ifElse calls, ensuring nested ternaries are properly transformed. Also strips parentheses from AST to match expected output. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

- Add fixture loading utilities to test-utils.ts - Create test/fixtures directory structure for transformation tests - Extract 36 test cases from hardcoded strings into .ts/.tsx fixtures - Add example test file demonstrating fixture usage - Document fixture structure and usage in README This makes tests more maintainable with real TypeScript files that have proper syntax highlighting, IDE support, and clearer version control diffs. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Verifies that expressions like `5 - (sale ? 1 : 0)` where sale is an OpaqueRef are correctly transformed to derive(sale, _v1 => 5 - (_v1 ? 1 : 0)) 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Verifies that array elements containing OpaqueRef operations are transformed independently. For example, [a + 1, b - 1] becomes [derive(a, _v1 => _v1 + 1), derive(b, _v1 => _v1 - 1)] 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

- Document OpaqueRef transformation rules and rationale in fixtures README - Add "principle of independent reactivity" for array/object transformations - List future test cases to implement - Add test fixture for object literals with OpaqueRef operations - Verify each property transforms independently: { x: a + 1, y: b * 2 } The principle of independent reactivity ensures minimal recomputation by making each reactive value depend only on its specific OpaqueRef inputs. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Update check.sh to explicitly list js-runtime files and directories, excluding the test/fixtures directory that contains TypeScript fixture files used for transformer testing. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

- Special handling for ternary expressions to check after child transformation - Transforms (opaque > 5 ? 1 : 2) to ifElse(derive(opaque, _v1 => _v1 > 5), 1, 2) - Detects when condition contains OpaqueRef or was transformed to derive() - Add test fixture to verify correct transformation This ensures ternary expressions are properly transformed to ifElse when their condition becomes an OpaqueRef through transformation. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Changed the return type of OpaqueRefMethods<T>.get() from OpaqueRef<T> to T. This fixes the type definition to match the actual runtime behavior where calling .get() on an OpaqueRef returns the underlying value, not another OpaqueRef. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Added support for transforming function calls that contain OpaqueRef expressions in their arguments. When a function call has arguments with OpaqueRef operations (like `a + 1`), the entire call is wrapped in a derive() function. Examples: - someFunction(a + 1, "prefix") → derive(a, _v1 => someFunction(_v1 + 1, "prefix")) - complexFunction(a * 2, "test") → derive(a, _v1 => complexFunction(_v1 * 2, "test")) This allows OpaqueRef values to be used in function arguments while maintaining reactivity. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

The transformer now consistently outputs imports in alphabetical order (cell, derive) instead of (derive, cell). 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Updated test expectations to match the new behavior where function calls containing OpaqueRef expressions are wrapped entirely in derive(). This is more efficient than individual derive calls for each expression. - Updated JSX expression test to expect pre-extracted values - Updated ifElse transform test to reflect wrapped recipe calls - Updated nested ternary test to expect both ternaries transformed - Fixed TypeScript compiler host type signatures in test-utils 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Added the function call transformation test to the fixtures test suite and cleaned up the array input file to use consistent imports. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

- Removed console.log statements from test files - Commented out verbose transformer logging - Made test expectations more concise 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Added test case for: total = price - (prime ? discount : pitance) This tests the transformation of complex expressions containing ternary operators within binary operations with OpaqueRef values. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Transforms function calls with OpaqueRef arguments into derive() calls: - Math.max(a, 10) becomes derive(a, _v1 => Math.max(_v1, 10)) - someFunction(a + 1, "prefix") becomes derive(a, _v1 => someFunction(_v1 + 1, "prefix")) Also: - Add support for both "@commontools/common" and legacy "commontools" imports - Fix import handling to use AMD module alias only for "commontools" imports - Add test coverage for JSX expression transformations - Update fixture files to match expected transformation behavior 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Simplify import handling to only support "commontools" imports. The transformer now consistently uses AMD-style module references (commontools_1.derive, commontools_1.ifElse) for all commontools imports. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

All schema transform test fixtures now include the /// <cts-enable /> directive, except for no-directive.input.ts which specifically tests behavior without the directive. This ensures tests pass with the new requirement that transformers only operate on files with the directive. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Add support for extracting default values from complex type literals in the Default<T, V> type. Previously only primitive literals (strings, numbers, booleans) were supported. Now supports: - Empty arrays: Default<string[], []> - Array literals: Default<string[], ["a", "b", "c"]> - Object literals: Default<{x: number}, {x: 42}> - Nested structures: Default<number[][], [[1, 2], [3, 4]]> - Null values: Default<string < /dev/null | null, null> The implementation adds extractValueFromTypeNode() which can parse TypeScript type nodes (TupleType, TypeLiteral, etc.) and extract their literal values for use as JSON schema defaults. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Change handler API to require explicit opt-in for proxy mode. By default, handlers now receive read-only state objects that work with the AST transformer. Key changes: - Add optional `options` parameter to handler() with `proxy` boolean - Update HandlerFunction type with conditional overloads: - When proxy: true - handlers receive mutable proxy types - When proxy: false/undefined - handlers receive read-only HandlerState types - HandlerState<T> makes non-Cell/Stream properties readonly - Update all tests using proxy mutations to include { proxy: true } This ensures handlers work correctly with the TypeScript AST transformer by default, while still supporting the proxy style when explicitly requested. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Add type overloads to support handler functions that use explicit 'this' parameter typing. The overloads respect the proxy mode setting: - With proxy: true - 'this' has mutable proxy types - With proxy: false/undefined - 'this' should have readonly HandlerState types Note: There's a TypeScript limitation where explicit 'this' type annotations override our type transformations. When users write: function(this: { counter: { value: number } }, ...) TypeScript uses that explicit type, bypassing our readonly protections. This is a known limitation - the runtime still enforces proxy mode correctly, but compile-time type checking can't catch mutations when 'this' is explicitly typed. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Update expected output files to match the actual formatting produced by the schema transformer when handling complex default values: - Object defaults are formatted with properties on separate lines - Array oneOf formatting uses array literal syntax - Add missing default values for arrays in default-type test - Remove default: undefined (undefined values don't have defaults) All js-runtime tests now pass with the enhanced Default type support. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

- Modified OpaqueRef transformer to only transform operations within JSX expression contexts - Statement-level transformations (if, while, variable declarations) are no longer performed - Added helper function isInsideJsxExpression() to check context - Fixed commontools_1 import alias issue - Updated test fixtures to reflect correct transformation behavior - Added applySchemaTransformer option to JSX expression tests - Updated AST documentation to clarify transformation scope and goals This is an architectural decision to avoid complex control flow analysis required for statement-level transformations. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

- Converted all JSX expression test fixtures to use recipe format - Updated expected outputs to include commontools_1.derive transformations - All JSX Expression Transformer tests now passing 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

- Restored AMD module alias in getCommonToolsModuleAlias for runtime compatibility - Updated AST documentation to clarify OpaqueRef transformations limited to JSX 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

- Added jsx-arithmetic-operations for all math operations - Added jsx-string-operations for string concat and methods - Added jsx-conditional-rendering for ternary/ifElse cases - Added jsx-property-access for object/array access patterns - Added jsx-function-calls for Math/string/array methods - Added jsx-complex-mixed for array operations and attributes - Removed simple-opaque-ref fixture (redundant) - Updated existing fixtures to match current transformer behavior These new fixtures provide better coverage of OpaqueRef transformations in JSX expressions and will replace the non-JSX fixtures. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Remove ~20 non-JSX fixtures that tested OpaqueRef transformations outside of JSX contexts. These have been replaced by comprehensive JSX expression fixtures that test transformations where they actually apply. Deleted: - All fixtures in test/fixtures/opaque-refs/ - ast-transform/binary-operation fixture - transformations/ifelse/odd-even-ternary fixture 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

Update test infrastructure after limiting OpaqueRef transformations to JSX expression contexts only: - Remove deleted fixture directories from fixture-based.test.ts - Update opaque-ref.test.ts to wrap all operations in JSX contexts - Fix schema transformer expected output - Remove redundant CTS-Enable directive test All tests now pass with JSX-only transformations. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

anotherjesse temporarily deployed to ci July 17, 2025 14:35 — with GitHub Actions Inactive

anotherjesse temporarily deployed to ci July 17, 2025 14:37 — with GitHub Actions Inactive

cubic-dev-ai bot reviewed Jul 17, 2025

View reviewed changes

anotherjesse and others added 25 commits July 17, 2025 14:46

ast for ternary

0003b9c

wip on binary expressions like cell.value + 1

f096fb9

refactor

e3c10f7

simplify import helpers

9130140

support multiple opaquerefs

ad2e563

{c1 + c2} or {c1 ? c1 : c2} should work

add opaque refs tests

bb661e4

cleanup

1842330

fix: correct import order in array fixture expected output

63e360a

The transformer now consistently outputs imports in alphabetical order (cell, derive) instead of (derive, cell). 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>

fix imports

3825ecc

anotherjesse and others added 5 commits July 17, 2025 14:46

anotherjesse force-pushed the ts-rebase-rebase branch from d02c64b to 248b6ab Compare July 17, 2025 14:47

anotherjesse temporarily deployed to ci July 17, 2025 14:50 — with GitHub Actions Inactive

anotherjesse temporarily deployed to ci July 17, 2025 14:51 — with GitHub Actions Inactive

anotherjesse temporarily deployed to ci July 17, 2025 15:07 — with GitHub Actions Inactive

cleanup recipes

7ae29af

anotherjesse force-pushed the ts-rebase-rebase branch from d5d7cca to 7ae29af Compare July 17, 2025 15:08

anotherjesse temporarily deployed to ci July 17, 2025 15:10 — with GitHub Actions Inactive

anotherjesse temporarily deployed to ci July 17, 2025 15:12 — with GitHub Actions Inactive

anotherjesse added 2 commits July 17, 2025 08:30

more cleanup

41991f0

first pass at updating rss.tsx

aec09fa

anotherjesse temporarily deployed to ci July 17, 2025 15:45 — with GitHub Actions Inactive

anotherjesse temporarily deployed to ci July 17, 2025 15:47 — with GitHub Actions Inactive

anotherjesse and others added 6 commits July 17, 2025 22:47

anotherjesse closed this Jul 29, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

AST again (rebase) #1429

AST again (rebase) #1429

Uh oh!

anotherjesse commented Jul 17, 2025

Uh oh!

cubic-dev-ai bot left a comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

	<ct-button onClick={increment({ value: state.value })}>+</ct-button>
	<ct-button onClick={() => increment({ value: state.value })}>+</ct-button>

	<button type="button" onClick={adder({ values })}>Add Value</button>
	<button type="button" onClick={() => adder({ values })}>Add Value</button>

AST again (rebase) #1429

AST again (rebase) #1429

Uh oh!

Conversation

anotherjesse commented Jul 17, 2025

Uh oh!

cubic-dev-ai bot left a comment

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants