@typespec/emitter-framework 0.6.0-dev.6 → 0.7.0-dev.0

package/dist/test/typescript/components/union-declaration.test.js

@@ -1,15 +1,18 @@
 import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
-import { Output, render } from "@alloy-js/core";
+import { render } from "@alloy-js/core";
 import { SourceFile } from "@alloy-js/typescript";
 import { format } from "prettier";
 import { assert, describe, expect, it } from "vitest";
+import { Output } from "../../../src/core/components/output.js";
 import { UnionDeclaration } from "../../../src/typescript/components/union-declaration.js";
 import { UnionExpression } from "../../../src/typescript/components/union-expression.js";
 import { getProgram } from "../test-host.js";
 describe("Typescript Union Declaration", () => {
   describe("Union not bound to Typespec Types", () => {
     it("creates a union declaration", async () => {
+      const program = await getProgram("");
       const res = render(_$createComponent(Output, {
+        program: program,
         get children() {
           return _$createComponent(SourceFile, {
             path: "test.ts",
@@ -46,6 +49,7 @@ describe("Typescript Union Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const union = Array.from(namespace.unions.values())[0];
         const res = render(_$createComponent(Output, {
+          program: program,
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
@@ -78,6 +82,7 @@ describe("Typescript Union Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const union = Array.from(namespace.unions.values())[0];
         const res = render(_$createComponent(Output, {
+          program: program,
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
@@ -112,6 +117,7 @@ describe("Typescript Union Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const union = Array.from(namespace.unions.values())[0];
         const res = render(_$createComponent(Output, {
+          program: program,
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
@@ -145,6 +151,7 @@ describe("Typescript Union Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const union = Array.from(namespace.unions.values())[0];
         const res = render(_$createComponent(Output, {
+          program: program,
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
@@ -179,6 +186,7 @@ describe("Typescript Union Declaration", () => {
         const [namespace] = program.resolveTypeReference("DemoService");
         const union = Array.from(namespace.enums.values())[0];
         const res = render(_$createComponent(Output, {
+          program: program,
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",

package/dist/test/typescript/components/value-expression.test.js

@@ -6,21 +6,22 @@ import { Numeric } from "@typespec/compiler";
 import { $ } from "@typespec/compiler/experimental/typekit";
 import { assert, beforeAll, describe, expect, it } from "vitest";
 import { ValueExpression } from "../../../src/typescript/components/value-expression.js";
-import { getProgram, initEmptyProgram } from "../test-host.js";
+import { getProgram } from "../test-host.js";
+let program;
 beforeAll(async () => {
-  await initEmptyProgram();
+  program = await getProgram("");
 });
 it("renders strings", async () => {
-  const value = $.value.createString("test");
+  const value = $(program).value.createString("test");
   await testValueExpression(value, `"test"`);
 });
 describe("numeric values", () => {
   it("renders integers", async () => {
-    const value = $.value.createNumeric(42);
+    const value = $(program).value.createNumeric(42);
     await testValueExpression(value, `42`);
   });
   it("renders decimals", async () => {
-    const value = $.value.createNumeric(42.5);
+    const value = $(program).value.createNumeric(42.5);
     await testValueExpression(value, `42.5`);
   });
   it("renders bigints", async () => {
@@ -43,7 +44,7 @@ describe("numeric values", () => {
   });
 });
 it("renders booleans", async () => {
-  const value = $.value.createBoolean(true);
+  const value = $(program).value.createBoolean(true);
   await testValueExpression(value, `true`);
 });
 it("renders nulls", async () => {
@@ -64,11 +65,12 @@ it("renders empty arrays", async () => {
   await testValueExpression(value, `[]`);
 });
 it("renders arrays with mixed values", async () => {
+  const tk = $(program);
   // Can be replaced with with TypeKit once #6976 is implemented
   const value = {
     entityKind: "Value",
     valueKind: "ArrayValue",
-    values: [$.value.createString("foo"), $.value.createNumeric(42), $.value.createBoolean(true)]
+    values: [tk.value.createString("foo"), tk.value.createNumeric(42), tk.value.createBoolean(true)]
   };
   await testValueExpression(value, `["foo", 42, true]`);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.6.0-dev.6",
+  "version": "0.7.0-dev.0",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -21,9 +21,9 @@
   "peerDependencies": {
     "@alloy-js/core": "^0.11.0",
     "@alloy-js/typescript": "^0.11.0",
-    "@typespec/compiler": "^1.0.0-rc.0",
-    "@typespec/http": "^1.0.0-rc.0",
-    "@typespec/rest": "^0.68.0 || >=0.69.0-dev <0.69.0"
+    "@typespec/compiler": "^1.0.0-rc.1",
+    "@typespec/http": "^1.0.0-rc.1",
+    "@typespec/rest": "^0.69.0 || >=0.70.0-dev <0.70.0"
   },
   "devDependencies": {
     "@alloy-js/cli": "^0.11.0",
@@ -31,9 +31,9 @@
     "@alloy-js/core": "^0.11.0",
     "@alloy-js/typescript": "^0.11.0",
     "@types/minimist": "^1.2.5",
-    "@typespec/compiler": "^1.0.0-rc.0",
-    "@typespec/http": "^1.0.0-rc.0",
-    "@typespec/rest": "^0.68.0 || >=0.69.0-dev <0.69.0",
+    "@typespec/compiler": "^1.0.0-rc.1",
+    "@typespec/http": "^1.0.0-rc.1",
+    "@typespec/rest": "^0.69.0 || >=0.70.0-dev <0.70.0",
     "concurrently": "^9.1.2",
     "minimist": "^1.2.8",
     "prettier": "~3.5.3",

package/src/core/components/index.tsx

@@ -0,0 +1 @@
+export * from "./output.jsx";

package/src/core/components/output.tsx

@@ -0,0 +1,19 @@
+import * as ay from "@alloy-js/core";
+import { Program } from "@typespec/compiler";
+import { TspContext } from "../context/tsp-context.js";
+
+export interface OutputProps extends ay.OutputProps {
+  /**
+   * TypeSpec program.
+   */
+  program: Program;
+}
+
+export function Output(props: OutputProps) {
+  const [{ program }, rest] = ay.splitProps(props, ["program"]);
+  return (
+    <TspContext.Provider value={{ program }}>
+      <ay.Output {...rest} />
+    </TspContext.Provider>
+  );
+}

package/src/core/context/index.ts

@@ -1 +1,2 @@
 export * from "./name-policy-context.js";
+export * from "./tsp-context.js";

package/src/core/context/tsp-context.ts

@@ -0,0 +1,30 @@
+import { ComponentContext, createNamedContext, useContext } from "@alloy-js/core";
+import { Program } from "@typespec/compiler";
+import { unsafe_$ } from "@typespec/compiler/experimental";
+import { Typekit } from "@typespec/compiler/experimental/typekit";
+
+export type TspContext = {
+  program: Program;
+  $: Typekit;
+};
+
+export const TspContext: ComponentContext<{ program: Program; $?: Typekit }> = createNamedContext<{
+  program: Program;
+  $?: Typekit;
+}>("TspContext");
+
+export function useTsp() {
+  const context = useContext(TspContext)!;
+
+  if (!context) {
+    throw new Error(
+      "TspContext is not set. Make sure the component is wrapped in TspContext.Provider or the emitter framework Output component.",
+    );
+  }
+
+  if (!context.$) {
+    context.$ = unsafe_$(context.program);
+  }
+
+  return context as TspContext;
+}

package/src/core/index.ts

@@ -1,3 +1,4 @@
+export * from "./components/index.js";
 export * from "./context/index.js";
 export * from "./transport-name-policy.js";
 export * from "./write-output.js";

package/src/core/write-output.ts

@@ -1,18 +1,25 @@
 import { Children, OutputDirectory, render } from "@alloy-js/core";
-import { emitFile, joinPaths } from "@typespec/compiler";
-import { unsafe_$ as $ } from "@typespec/compiler/experimental";
+import { emitFile, joinPaths, Program } from "@typespec/compiler";
 
-export async function writeOutput(rootComponent: Children, emitterOutputDir: string) {
+export async function writeOutput(
+  program: Program,
+  rootComponent: Children,
+  emitterOutputDir: string,
+) {
   const tree = render(rootComponent);
-  await writeOutputDirectory(tree, emitterOutputDir);
+  await writeOutputDirectory(program, tree, emitterOutputDir);
 }
 
-async function writeOutputDirectory(dir: OutputDirectory, emitterOutputDir: string) {
+async function writeOutputDirectory(
+  program: Program,
+  dir: OutputDirectory,
+  emitterOutputDir: string,
+) {
   for (const sub of dir.contents) {
     if (Array.isArray(sub.contents)) {
-      await writeOutputDirectory(sub as OutputDirectory, emitterOutputDir);
+      await writeOutputDirectory(program, sub as OutputDirectory, emitterOutputDir);
     } else {
-      await emitFile($.program, {
+      await emitFile(program, {
         content: sub.contents as string,
         path: joinPaths(emitterOutputDir, sub.path),
       });

package/src/typescript/components/enum-declaration.tsx

@@ -1,7 +1,7 @@
 import * as ay from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { Enum, EnumMember as TspEnumMember, Union } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
+import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
 
 export interface EnumDeclarationProps extends Omit<ts.TypeDeclarationProps, "name"> {
@@ -10,6 +10,7 @@ export interface EnumDeclarationProps extends Omit<ts.TypeDeclarationProps, "nam
 }
 
 export function EnumDeclaration(props: EnumDeclarationProps) {
+  const { $ } = useTsp();
   let type: Enum;
   if ($.union.is(props.type)) {
     if (!$.union.isValidEnum(props.type)) {

package/src/typescript/components/interface-declaration.tsx

@@ -9,8 +9,9 @@ import {
   Operation,
   RekeyableMap,
 } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
+import { Typekit } from "@typespec/compiler/experimental/typekit";
 import { createRekeyableMap } from "@typespec/compiler/utils";
+import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
 import { InterfaceMember } from "./interface-member.js";
 import { TypeExpression } from "./type-expression.jsx";
@@ -24,6 +25,8 @@ export type InterfaceDeclarationProps =
   | ts.InterfaceDeclarationProps;
 
 export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
+  const { $ } = useTsp();
+
   if (!isTypedInterfaceDeclarationProps(props)) {
     return <ts.InterfaceDeclaration {...props} />;
   }
@@ -40,7 +43,7 @@ export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
 
   const refkey = props.refkey ?? getRefkey(props.type);
 
-  const extendsType = props.extends ?? getExtendsType(props.type);
+  const extendsType = props.extends ?? getExtendsType($, props.type);
 
   return (
     <ts.InterfaceDeclaration
@@ -74,7 +77,7 @@ export function InterfaceExpression(props: InterfaceExpressionProps) {
   );
 }
 
-function getExtendsType(type: Model | Interface): Children | undefined {
+function getExtendsType($: Typekit, type: Model | Interface): Children | undefined {
   if (!$.model.is(type)) {
     return undefined;
   }
@@ -120,6 +123,7 @@ function getExtendsType(type: Model | Interface): Children | undefined {
  * Renders the members of an interface from its properties, including any additional children.
  */
 function InterfaceBody(props: TypedInterfaceDeclarationProps): Children {
+  const { $ } = useTsp();
   let typeMembers: RekeyableMap<string, ModelProperty | Operation> | undefined;
   if ($.model.is(props.type)) {
     typeMembers = $.model.getProperties(props.type);

package/src/typescript/components/interface-member.tsx

@@ -1,7 +1,7 @@
 import * as ts from "@alloy-js/typescript";
 import { isNeverType, ModelProperty, Operation } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
 import { getHttpPart } from "@typespec/http";
+import { useTsp } from "../../core/context/tsp-context.js";
 import { InterfaceMethod } from "./interface-method.jsx";
 import { TypeExpression } from "./type-expression.js";
 
@@ -11,6 +11,7 @@ export interface InterfaceMemberProps {
 }
 
 export function InterfaceMember(props: InterfaceMemberProps) {
+  const { $ } = useTsp();
   const namer = ts.useTSNamePolicy();
   const name = namer.getName(props.type.name, "object-member-getter");
 

package/src/typescript/components/type-alias-declaration.tsx

@@ -1,7 +1,7 @@
 import { refkey as getRefkey } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { Type } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
+import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
 import { TypeExpression } from "./type-expression.jsx";
 
@@ -17,6 +17,7 @@ export type TypeAliasDeclarationProps = TypedAliasDeclarationProps | ts.TypeDecl
  * type alias as the provided TypeSpec type.
  */
 export function TypeAliasDeclaration(props: TypeAliasDeclarationProps) {
+  const { $ } = useTsp();
   if (!isTypedAliasDeclarationProps(props)) {
     return <ts.TypeDeclaration {...props}>{props.children}</ts.TypeDeclaration>;
   }

package/src/typescript/components/type-expression.tsx

@@ -1,8 +1,9 @@
 import { For, refkey } from "@alloy-js/core";
 import { Reference, ValueExpression } from "@alloy-js/typescript";
 import { IntrinsicType, Model, Scalar, Type } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
+import { Typekit } from "@typespec/compiler/experimental/typekit";
 import "@typespec/http/experimental/typekit";
+import { useTsp } from "../../core/context/tsp-context.js";
 import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
 import { ArrayExpression } from "./array-expression.js";
 import { FunctionType } from "./function-type.js";
@@ -22,8 +23,9 @@ export interface TypeExpressionProps {
 }
 
 export function TypeExpression(props: TypeExpressionProps) {
+  const { $ } = useTsp();
   const type = $.httpPart.unpack(props.type);
-  if (!props.noReference && isDeclaration(type)) {
+  if (!props.noReference && isDeclaration($, type)) {
     // todo: probably need abstraction around deciding what's a declaration in the output
     // (it may not correspond to things which are declarations in TypeSpec?)
     return <Reference refkey={refkey(type)} />;
@@ -34,7 +36,7 @@ export function TypeExpression(props: TypeExpressionProps) {
   switch (type.kind) {
     case "Scalar":
     case "Intrinsic":
-      return <>{getScalarIntrinsicExpression(type)}</>;
+      return <>{getScalarIntrinsicExpression($, type)}</>;
     case "Boolean":
     case "Number":
     case "String":
@@ -119,7 +121,7 @@ const intrinsicNameToTSType = new Map<string, string | null>([
   ["url", "string"], // Matches TypeScript's `string`
 ]);
 
-function getScalarIntrinsicExpression(type: Scalar | IntrinsicType): string | null {
+function getScalarIntrinsicExpression($: Typekit, type: Scalar | IntrinsicType): string | null {
   let intrinsicName: string;
   if ($.scalar.is(type)) {
     if ($.scalar.isUtcDateTime(type) || $.scalar.extendsUtcDateTime(type)) {
@@ -152,7 +154,7 @@ function getScalarIntrinsicExpression(type: Scalar | IntrinsicType): string | nu
   return tsType;
 }
 
-function isDeclaration(type: Type): boolean {
+function isDeclaration($: Typekit, type: Type): boolean {
   switch (type.kind) {
     case "Namespace":
     case "Interface":

package/src/typescript/components/type-transform.tsx

@@ -9,8 +9,9 @@ import {
   Type,
   Union,
 } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
+import { Typekit } from "@typespec/compiler/experimental/typekit";
 import { createRekeyableMap } from "@typespec/compiler/utils";
+import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
 import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
 import {
@@ -33,6 +34,7 @@ export interface UnionTransformProps {
   target: "application" | "transport";
 }
 function UnionTransformExpression(props: UnionTransformProps) {
+  const { $ } = useTsp();
   const discriminator = $.type.getDiscriminator(props.type);
 
   if (!discriminator) {
@@ -56,6 +58,7 @@ interface DiscriminateExpressionProps {
 }
 
 function DiscriminateExpression(props: DiscriminateExpressionProps) {
+  const { $ } = useTsp();
   const discriminatedUnion = $.model.is(props.type)
     ? $.model.getDiscriminatedUnion(props.type)
     : $.union.getDiscriminatedUnion(props.type);
@@ -89,6 +92,7 @@ function DiscriminateExpression(props: DiscriminateExpressionProps) {
  * Component that represents a function declaration that transforms a model to a transport or application model.
  */
 export function TypeTransformDeclaration(props: TypeTransformProps) {
+  const { $ } = useTsp();
   const namePolicy = ts.useTSNamePolicy();
 
   // Record and array have their general serializers
@@ -179,6 +183,7 @@ export interface ModelTransformExpressionProps {
  * Component that represents an object expression that transforms a model to a transport or application model.
  */
 export function ModelTransformExpression(props: ModelTransformExpressionProps) {
+  const { $ } = useTsp();
   if (props.type.baseModel) {
     reportTypescriptDiagnostic($.program, {
       code: "typescript-extended-model-transform-nyi",
@@ -233,7 +238,7 @@ export function ModelTransformExpression(props: ModelTransformExpressionProps) {
             <TypeTransformCall target={props.target} type={unpackedType} itemPath={itemPath} />
           );
 
-          if (property.optional && needsTransform(unpackedType)) {
+          if (property.optional && needsTransform($, unpackedType)) {
             value = (
               <>
                 {itemPath.join(".")} ?{" "}
@@ -260,6 +265,7 @@ interface TransformReferenceProps {
  * Given a type and target, gets the reference to the transform function
  */
 function TransformReference(props: TransformReferenceProps) {
+  const { $ } = useTsp();
   if ($.scalar.is(props.type)) {
     return <TransformScalarReference type={props.type} target={props.target} />;
   }
@@ -290,6 +296,7 @@ interface TransformScalarReferenceProps {
  * Handles scalar transformations
  */
 function TransformScalarReference(props: TransformScalarReferenceProps) {
+  const { $ } = useTsp();
   let reference: Refkey | undefined;
   if ($.scalar.isUtcDateTime(props.type)) {
     // TODO: Handle encoding, likely to need access to parents to avoid passing the modelProperty
@@ -331,7 +338,7 @@ export interface TypeTransformCallProps {
   optionsBagName?: string;
 }
 
-function needsTransform(type: Type): boolean {
+function needsTransform($: Typekit, type: Type): boolean {
   return $.model.is(type) || $.scalar.isUtcDateTime(type);
 }
 
@@ -339,7 +346,8 @@ function needsTransform(type: Type): boolean {
  * This component represents a function call to transform a type
  */
 export function TypeTransformCall(props: TypeTransformCallProps): Children {
-  const collapsedProperty = getCollapsedProperty(props.type, props.collapse ?? false);
+  const { $ } = useTsp();
+  const collapsedProperty = getCollapsedProperty($, props.type, props.collapse ?? false);
   const itemPath = collapsedProperty
     ? [...(props.itemPath ?? []), collapsedProperty.name]
     : (props.itemPath ?? []);
@@ -410,7 +418,11 @@ export function TypeTransformCall(props: TypeTransformCallProps): Children {
   return itemName;
 }
 
-function getCollapsedProperty(model: Type, collapse: boolean): ModelProperty | undefined {
+function getCollapsedProperty(
+  $: Typekit,
+  model: Type,
+  collapse: boolean,
+): ModelProperty | undefined {
   if (!$.model.is(model)) {
     return undefined;
   }

package/src/typescript/components/union-declaration.tsx

@@ -1,7 +1,7 @@
 import { refkey as getRefkey } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { Enum, Union } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
+import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
 import { UnionExpression } from "./union-expression.js";
 
@@ -13,6 +13,7 @@ export interface TypedUnionDeclarationProps extends Omit<ts.TypeDeclarationProps
 export type UnionDeclarationProps = TypedUnionDeclarationProps | ts.TypeDeclarationProps;
 
 export function UnionDeclaration(props: UnionDeclarationProps) {
+  const { $ } = useTsp();
   if (!isTypedUnionDeclarationProps(props)) {
     return <ts.TypeDeclaration {...props}>{props.children}</ts.TypeDeclaration>;
   }

package/src/typescript/components/union-expression.tsx

@@ -2,7 +2,7 @@ import * as ay from "@alloy-js/core";
 import { Children } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { Enum, EnumMember, Union, UnionVariant } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
+import { useTsp } from "../../core/context/tsp-context.js";
 import { TypeExpression } from "./type-expression.jsx";
 
 export interface UnionExpressionProps {
@@ -11,6 +11,7 @@ export interface UnionExpressionProps {
 }
 
 export function UnionExpression({ type, children }: UnionExpressionProps) {
+  const { $ } = useTsp();
   const items = ($.union.is(type) ? type.variants : type.members) as Map<
     string,
     UnionVariant | EnumMember

package/src/typescript/utils/operation.ts

@@ -1,13 +1,14 @@
 import { refkey as getRefkey } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { Model, ModelProperty, Operation, Type } from "@typespec/compiler";
-import { $ } from "@typespec/compiler/experimental/typekit";
+import { useTsp } from "../../core/index.js";
 import { TypeExpression } from "../components/type-expression.jsx";
 
 export function getReturnType(
   type: Operation,
   options: { skipErrorFiltering: boolean } = { skipErrorFiltering: false },
 ): Type {
+  const { $ } = useTsp();
   let returnType = type.returnType;
 
   if (!options.skipErrorFiltering && type.returnType.kind === "Union") {
@@ -26,6 +27,7 @@ export function buildParameterDescriptors(
   type: Model,
   options: BuildParameterDescriptorsOptions = {},
 ): ts.ParameterDescriptor[] | undefined {
+  const { $ } = useTsp();
   const optionsParams = normalizeParameters(options.params);
 
   if (options.mode === "replace") {

package/test/typescript/components/arrow-function.test.tsx

@@ -1,9 +1,10 @@
-import { Output, render } from "@alloy-js/core";
+import { render } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { SourceFile } from "@alloy-js/typescript";
 import { Operation } from "@typespec/compiler";
 import { BasicTestRunner } from "@typespec/compiler/testing";
 import { beforeEach, describe, it } from "vitest";
+import { Output } from "../../../src/core/components/output.jsx";
 import { ArrowFunction } from "../../../src/typescript/components/arrow-function.jsx";
 import { assertFileContents } from "../../utils.js";
 import { createEmitterFrameworkTestRunner } from "../test-host.js";
@@ -21,7 +22,7 @@ describe("arrow functions with a `type` prop", () => {
     `)) as { getName: Operation };
 
     const res = render(
-      <Output>
+      <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction type={getName}>console.log("Hello!");</ArrowFunction>
         </SourceFile>
@@ -44,7 +45,7 @@ describe("arrow functions with a `type` prop", () => {
     `)) as { getName: Operation };
 
     const res = render(
-      <Output>
+      <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction async type={getName} />
         </SourceFile>
@@ -65,7 +66,7 @@ describe("arrow functions with a `type` prop", () => {
     `)) as { getName: Operation };
 
     const res = render(
-      <Output>
+      <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction
             type={getName}