@ic-reactor/codegen 0.8.0 → 0.9.0

package/README.md

@@ -24,7 +24,9 @@ await runCanisterPipeline({
   globalConfig: {
     outDir: "src/declarations",
     clientManagerPath: "../../clients",
+    target: "react",
   },
+  generateReactor: true,
 })
 ```
 
@@ -38,8 +40,16 @@ Set `canisterConfig.mode` to choose the generated reactor class:
 - `CandidDisplayReactor`
 - `MetadataDisplayReactor`
 
+Set `target` to control whether generated files include React hooks:
+
+- `react` (default): generates the reactor plus bound `createActorHooks` exports
+- `core`: generates only the typed reactor exports with no `@ic-reactor/react` dependency
+
 Codegen now writes two files per canister: a managed `index.generated.ts` implementation that is regenerated on every run, and an `index.ts` entry wrapper. The wrapper is created once, then preserved unless it still matches the default generated wrapper or an older generated scaffold that can be migrated automatically.
 
+Set `generateReactor: false` if you only want the bindgen/declaration output and
+need to skip `index.generated.ts` and `index.ts`.
+
 ## Generators
 
 You can also use individual generators if you need more granular control:

package/dist/index.cjs

@@ -124,11 +124,11 @@ function getServiceTypeName(canisterName) {
 }
 
 // src/generators/reactor.ts
-function getReactorClassImportSource(reactorClass) {
+function getReactorClassImportSource(reactorClass, runtimeTarget) {
   switch (reactorClass) {
     case "Reactor":
     case "DisplayReactor":
-      return "@ic-reactor/react";
+      return runtimeTarget === "core" ? "@ic-reactor/core" : "@ic-reactor/react";
     case "CandidReactor":
     case "CandidDisplayReactor":
     case "MetadataDisplayReactor":
@@ -141,6 +141,7 @@ function generateReactorFile(options) {
     didFile,
     clientManagerPath = "../../clients",
     canisterId,
+    runtimeTarget = "react",
     reactorClass = "DisplayReactor"
   } = options;
   const pascalName = toPascalCase(canisterName);
@@ -148,11 +149,24 @@ function generateReactorFile(options) {
   const serviceName = getServiceTypeName(canisterName);
   const baseName = import_node_path2.default.basename(didFile, ".did");
   const declarationsPath = `./declarations/${baseName}`;
-  const reactorImportSource = getReactorClassImportSource(reactorClass);
+  const reactorImportSource = getReactorClassImportSource(
+    reactorClass,
+    runtimeTarget
+  );
   const canisterIdLine = canisterId ? `  canisterId: ${JSON.stringify(canisterId)},
 ` : "";
-  return `import { createActorHooks } from "@ic-reactor/react"
-import { ${reactorClass} } from "${reactorImportSource}"
+  const hookExports = runtimeTarget === "react" ? `
+
+export const {
+  useActorQuery: use${pascalName}Query,
+  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
+  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
+  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
+  useActorMutation: use${pascalName}Mutation,
+  useActorMethod: use${pascalName}Method,
+} = createActorHooks(${reactorName})
+` : "";
+  return `${runtimeTarget === "react" ? 'import { createActorHooks } from "@ic-reactor/react"\n' : ""}import { ${reactorClass} } from "${reactorImportSource}"
 import { clientManager } from "${clientManagerPath}"
 import { idlFactory, type _SERVICE } from "${declarationsPath}"
 
@@ -168,24 +182,14 @@ export const ${reactorName} = new ${reactorClass}<${serviceName}>({
   clientManager,
   idlFactory,
 ${canisterIdLine}  name: "${canisterName}",
-})
-
-export const {
-  useActorQuery: use${pascalName}Query,
-  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
-  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
-  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
-  useActorMutation: use${pascalName}Mutation,
-  useActorMethod: use${pascalName}Method,
-} = createActorHooks(${reactorName})
-`;
+})${hookExports || "\n"}`;
 }
 function generateReactorEntryFile() {
   return `/**
  * Canister entrypoint.
  *
  * Created once by @ic-reactor/codegen and safe to customize.
- * Keep the re-export below if you want generated hooks and types to stay in sync.
+ * Keep the re-export below if you want generated exports and types to stay in sync.
  */
 export * from "./index.generated"
 `;
@@ -195,6 +199,9 @@ export * from "./index.generated"
 function resolveReactorClass(canisterConfig) {
   return canisterConfig.mode ?? "DisplayReactor";
 }
+function resolveRuntimeTarget(canisterConfig, globalConfig) {
+  return canisterConfig.target ?? globalConfig.target ?? "react";
+}
 function normalizeFileContent(content) {
   return content.replace(/\r\n/g, "\n").trim();
 }
@@ -205,7 +212,12 @@ function isManagedEntryWrapper(content, expectedEntryContent) {
   return normalizeFileContent(content) === normalizeFileContent(expectedEntryContent);
 }
 async function runCanisterPipeline(options) {
-  const { canisterConfig, projectRoot, globalConfig } = options;
+  const {
+    canisterConfig,
+    projectRoot,
+    globalConfig,
+    generateReactor = true
+  } = options;
   const { name, didFile, clientManagerPath } = canisterConfig;
   const files = [];
   const resolvedDidFile = import_node_path3.default.isAbsolute(didFile) ? didFile : import_node_path3.default.resolve(projectRoot, didFile);
@@ -242,15 +254,24 @@ async function runCanisterPipeline(options) {
       error: `Declarations step failed: ${err instanceof Error ? err.message : String(err)}`
     };
   }
+  if (!generateReactor) {
+    return {
+      canisterName: name,
+      success: true,
+      files
+    };
+  }
   const reactorPath = import_node_path3.default.join(canisterOutDir, "index.generated.ts");
   const entryPath = import_node_path3.default.join(canisterOutDir, "index.ts");
   const reactorClass = resolveReactorClass(canisterConfig);
+  const runtimeTarget = resolveRuntimeTarget(canisterConfig, globalConfig);
   try {
     const reactorContent = generateReactorFile({
       canisterName: name,
       didFile: resolvedDidFile,
       clientManagerPath: resolvedClientManagerPath,
       canisterId: canisterConfig.canisterId,
+      runtimeTarget,
       reactorClass
     });
     const entryContent = generateReactorEntryFile();

package/dist/index.d.cts

@@ -24,10 +24,16 @@ interface CanisterConfig {
      * Defaults to DisplayReactor for backward compatibility.
      */
     mode?: ReactorClassName;
+    /**
+     * Generated runtime target.
+     * `react` emits bound React hooks, `core` emits only the typed reactor exports.
+     */
+    target?: CodegenTarget;
     /** Optional fixed canister ID */
     canisterId?: string;
 }
 type ReactorClassName = "Reactor" | "DisplayReactor" | "CandidReactor" | "CandidDisplayReactor" | "MetadataDisplayReactor";
+type CodegenTarget = "react" | "core";
 /**
  * Top-level codegen / CLI configuration (stored in `ic-reactor.json`).
  */
@@ -44,6 +50,11 @@ interface CodegenConfig {
      * Individual canisters can override via `CanisterConfig.clientManagerPath`.
      */
     clientManagerPath?: string;
+    /**
+     * Default generated runtime target.
+     * Individual canisters can override via `CanisterConfig.target`.
+     */
+    target?: CodegenTarget;
     /** Canister configurations, keyed by canister name */
     canisters: Record<string, CanisterConfig>;
 }
@@ -68,8 +79,8 @@ interface GeneratorResult {
  * Pipeline steps (in order):
  *  1. Resolve paths (didFile, outDir)
  *  2. Generate declarations (JS + .d.ts + .did copy)
- *  3. Generate reactor implementation (`index.generated.ts`)
- *  4. Create or migrate the user entry (`index.ts`)
+ *  3. Optionally generate reactor implementation (`index.generated.ts`)
+ *  4. Optionally create or migrate the user entry (`index.ts`)
  */
 
 interface PipelineOptions {
@@ -83,7 +94,12 @@ interface PipelineOptions {
     /**
      * Global codegen config (for fallback outDir and clientManagerPath).
      */
-    globalConfig: Pick<CodegenConfig, "outDir" | "clientManagerPath">;
+    globalConfig: Pick<CodegenConfig, "outDir" | "clientManagerPath" | "target">;
+    /**
+     * Whether the managed reactor files should be generated.
+     * Defaults to true.
+     */
+    generateReactor?: boolean;
 }
 interface PipelineResult {
     canisterName: string;
@@ -193,8 +209,8 @@ declare function declarationsExist(outDir: string, canisterName: string): boolea
 /**
  * Reactor File Generator
  *
- * Generates the managed `index.generated.ts` implementation for a canister
- * plus the full set of typed hooks via `createActorHooks`.
+ * Generates the managed `index.generated.ts` implementation for a canister.
+ * React targets also emit the full set of typed hooks via `createActorHooks`.
  *
  * Generated output example (for canister "backend"):
  *
@@ -227,6 +243,8 @@ interface ReactorGeneratorOptions {
     clientManagerPath?: string;
     /** Optional fixed canister ID for the generated reactor */
     canisterId?: string;
+    /** Generated runtime target */
+    runtimeTarget?: CodegenTarget;
     /**
      * Which reactor class should back the generated hooks.
      * Default: "DisplayReactor" (backward compatible)
@@ -265,4 +283,4 @@ interface ClientGeneratorOptions {
  */
 declare function generateClientFile(options?: ClientGeneratorOptions): string;
 
-export { type CanisterConfig, type ClientGeneratorOptions, type CodegenConfig, type DeclarationsGeneratorOptions, type DeclarationsGeneratorResult, type GeneratorResult, type MethodInfo, type MethodType, type PipelineOptions, type PipelineResult, type ReactorClassName, type ReactorGeneratorOptions, declarationsExist, extractMethods, generateClientFile, generateDeclarations, generateReactorEntryFile, generateReactorFile, getReactorName, getServiceTypeName, parseDIDFile, runCanisterPipeline, toPascalCase };
+export { type CanisterConfig, type ClientGeneratorOptions, type CodegenConfig, type CodegenTarget, type DeclarationsGeneratorOptions, type DeclarationsGeneratorResult, type GeneratorResult, type MethodInfo, type MethodType, type PipelineOptions, type PipelineResult, type ReactorClassName, type ReactorGeneratorOptions, declarationsExist, extractMethods, generateClientFile, generateDeclarations, generateReactorEntryFile, generateReactorFile, getReactorName, getServiceTypeName, parseDIDFile, runCanisterPipeline, toPascalCase };

package/dist/index.d.ts

@@ -24,10 +24,16 @@ interface CanisterConfig {
      * Defaults to DisplayReactor for backward compatibility.
      */
     mode?: ReactorClassName;
+    /**
+     * Generated runtime target.
+     * `react` emits bound React hooks, `core` emits only the typed reactor exports.
+     */
+    target?: CodegenTarget;
     /** Optional fixed canister ID */
     canisterId?: string;
 }
 type ReactorClassName = "Reactor" | "DisplayReactor" | "CandidReactor" | "CandidDisplayReactor" | "MetadataDisplayReactor";
+type CodegenTarget = "react" | "core";
 /**
  * Top-level codegen / CLI configuration (stored in `ic-reactor.json`).
  */
@@ -44,6 +50,11 @@ interface CodegenConfig {
      * Individual canisters can override via `CanisterConfig.clientManagerPath`.
      */
     clientManagerPath?: string;
+    /**
+     * Default generated runtime target.
+     * Individual canisters can override via `CanisterConfig.target`.
+     */
+    target?: CodegenTarget;
     /** Canister configurations, keyed by canister name */
     canisters: Record<string, CanisterConfig>;
 }
@@ -68,8 +79,8 @@ interface GeneratorResult {
  * Pipeline steps (in order):
  *  1. Resolve paths (didFile, outDir)
  *  2. Generate declarations (JS + .d.ts + .did copy)
- *  3. Generate reactor implementation (`index.generated.ts`)
- *  4. Create or migrate the user entry (`index.ts`)
+ *  3. Optionally generate reactor implementation (`index.generated.ts`)
+ *  4. Optionally create or migrate the user entry (`index.ts`)
  */
 
 interface PipelineOptions {
@@ -83,7 +94,12 @@ interface PipelineOptions {
     /**
      * Global codegen config (for fallback outDir and clientManagerPath).
      */
-    globalConfig: Pick<CodegenConfig, "outDir" | "clientManagerPath">;
+    globalConfig: Pick<CodegenConfig, "outDir" | "clientManagerPath" | "target">;
+    /**
+     * Whether the managed reactor files should be generated.
+     * Defaults to true.
+     */
+    generateReactor?: boolean;
 }
 interface PipelineResult {
     canisterName: string;
@@ -193,8 +209,8 @@ declare function declarationsExist(outDir: string, canisterName: string): boolea
 /**
  * Reactor File Generator
  *
- * Generates the managed `index.generated.ts` implementation for a canister
- * plus the full set of typed hooks via `createActorHooks`.
+ * Generates the managed `index.generated.ts` implementation for a canister.
+ * React targets also emit the full set of typed hooks via `createActorHooks`.
  *
  * Generated output example (for canister "backend"):
  *
@@ -227,6 +243,8 @@ interface ReactorGeneratorOptions {
     clientManagerPath?: string;
     /** Optional fixed canister ID for the generated reactor */
     canisterId?: string;
+    /** Generated runtime target */
+    runtimeTarget?: CodegenTarget;
     /**
      * Which reactor class should back the generated hooks.
      * Default: "DisplayReactor" (backward compatible)
@@ -265,4 +283,4 @@ interface ClientGeneratorOptions {
  */
 declare function generateClientFile(options?: ClientGeneratorOptions): string;
 
-export { type CanisterConfig, type ClientGeneratorOptions, type CodegenConfig, type DeclarationsGeneratorOptions, type DeclarationsGeneratorResult, type GeneratorResult, type MethodInfo, type MethodType, type PipelineOptions, type PipelineResult, type ReactorClassName, type ReactorGeneratorOptions, declarationsExist, extractMethods, generateClientFile, generateDeclarations, generateReactorEntryFile, generateReactorFile, getReactorName, getServiceTypeName, parseDIDFile, runCanisterPipeline, toPascalCase };
+export { type CanisterConfig, type ClientGeneratorOptions, type CodegenConfig, type CodegenTarget, type DeclarationsGeneratorOptions, type DeclarationsGeneratorResult, type GeneratorResult, type MethodInfo, type MethodType, type PipelineOptions, type PipelineResult, type ReactorClassName, type ReactorGeneratorOptions, declarationsExist, extractMethods, generateClientFile, generateDeclarations, generateReactorEntryFile, generateReactorFile, getReactorName, getServiceTypeName, parseDIDFile, runCanisterPipeline, toPascalCase };

package/dist/index.js

@@ -78,11 +78,11 @@ function getServiceTypeName(canisterName) {
 }
 
 // src/generators/reactor.ts
-function getReactorClassImportSource(reactorClass) {
+function getReactorClassImportSource(reactorClass, runtimeTarget) {
   switch (reactorClass) {
     case "Reactor":
     case "DisplayReactor":
-      return "@ic-reactor/react";
+      return runtimeTarget === "core" ? "@ic-reactor/core" : "@ic-reactor/react";
     case "CandidReactor":
     case "CandidDisplayReactor":
     case "MetadataDisplayReactor":
@@ -95,6 +95,7 @@ function generateReactorFile(options) {
     didFile,
     clientManagerPath = "../../clients",
     canisterId,
+    runtimeTarget = "react",
     reactorClass = "DisplayReactor"
   } = options;
   const pascalName = toPascalCase(canisterName);
@@ -102,11 +103,24 @@ function generateReactorFile(options) {
   const serviceName = getServiceTypeName(canisterName);
   const baseName = path2.basename(didFile, ".did");
   const declarationsPath = `./declarations/${baseName}`;
-  const reactorImportSource = getReactorClassImportSource(reactorClass);
+  const reactorImportSource = getReactorClassImportSource(
+    reactorClass,
+    runtimeTarget
+  );
   const canisterIdLine = canisterId ? `  canisterId: ${JSON.stringify(canisterId)},
 ` : "";
-  return `import { createActorHooks } from "@ic-reactor/react"
-import { ${reactorClass} } from "${reactorImportSource}"
+  const hookExports = runtimeTarget === "react" ? `
+
+export const {
+  useActorQuery: use${pascalName}Query,
+  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
+  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
+  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
+  useActorMutation: use${pascalName}Mutation,
+  useActorMethod: use${pascalName}Method,
+} = createActorHooks(${reactorName})
+` : "";
+  return `${runtimeTarget === "react" ? 'import { createActorHooks } from "@ic-reactor/react"\n' : ""}import { ${reactorClass} } from "${reactorImportSource}"
 import { clientManager } from "${clientManagerPath}"
 import { idlFactory, type _SERVICE } from "${declarationsPath}"
 
@@ -122,24 +136,14 @@ export const ${reactorName} = new ${reactorClass}<${serviceName}>({
   clientManager,
   idlFactory,
 ${canisterIdLine}  name: "${canisterName}",
-})
-
-export const {
-  useActorQuery: use${pascalName}Query,
-  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
-  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
-  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
-  useActorMutation: use${pascalName}Mutation,
-  useActorMethod: use${pascalName}Method,
-} = createActorHooks(${reactorName})
-`;
+})${hookExports || "\n"}`;
 }
 function generateReactorEntryFile() {
   return `/**
  * Canister entrypoint.
  *
  * Created once by @ic-reactor/codegen and safe to customize.
- * Keep the re-export below if you want generated hooks and types to stay in sync.
+ * Keep the re-export below if you want generated exports and types to stay in sync.
  */
 export * from "./index.generated"
 `;
@@ -149,6 +153,9 @@ export * from "./index.generated"
 function resolveReactorClass(canisterConfig) {
   return canisterConfig.mode ?? "DisplayReactor";
 }
+function resolveRuntimeTarget(canisterConfig, globalConfig) {
+  return canisterConfig.target ?? globalConfig.target ?? "react";
+}
 function normalizeFileContent(content) {
   return content.replace(/\r\n/g, "\n").trim();
 }
@@ -159,7 +166,12 @@ function isManagedEntryWrapper(content, expectedEntryContent) {
   return normalizeFileContent(content) === normalizeFileContent(expectedEntryContent);
 }
 async function runCanisterPipeline(options) {
-  const { canisterConfig, projectRoot, globalConfig } = options;
+  const {
+    canisterConfig,
+    projectRoot,
+    globalConfig,
+    generateReactor = true
+  } = options;
   const { name, didFile, clientManagerPath } = canisterConfig;
   const files = [];
   const resolvedDidFile = path3.isAbsolute(didFile) ? didFile : path3.resolve(projectRoot, didFile);
@@ -196,15 +208,24 @@ async function runCanisterPipeline(options) {
       error: `Declarations step failed: ${err instanceof Error ? err.message : String(err)}`
     };
   }
+  if (!generateReactor) {
+    return {
+      canisterName: name,
+      success: true,
+      files
+    };
+  }
   const reactorPath = path3.join(canisterOutDir, "index.generated.ts");
   const entryPath = path3.join(canisterOutDir, "index.ts");
   const reactorClass = resolveReactorClass(canisterConfig);
+  const runtimeTarget = resolveRuntimeTarget(canisterConfig, globalConfig);
   try {
     const reactorContent = generateReactorFile({
       canisterName: name,
       didFile: resolvedDidFile,
       clientManagerPath: resolvedClientManagerPath,
       canisterId: canisterConfig.canisterId,
+      runtimeTarget,
       reactorClass
     });
     const entryContent = generateReactorEntryFile();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/codegen",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Shared code generation utilities for IC Reactor",
   "type": "module",
   "main": "./dist/index.cjs",

package/src/__snapshots__/reactor.test.ts.snap

@@ -92,3 +92,24 @@ export const {
 } = createActorHooks(ledgerReactor)
 "
 `;
+
+exports[`Reactor generator > supports core target generation without React hooks > core-display-reactor-index 1`] = `
+"import { DisplayReactor } from "@ic-reactor/core"
+import { clientManager } from "../../clients"
+import { idlFactory, type _SERVICE } from "./declarations/backend"
+
+export type BackendService = _SERVICE
+
+/**
+ * Backend Reactor
+ *
+ * Auto-generated by @ic-reactor/codegen — do not edit.
+ * This file is overwritten whenever generation runs.
+ */
+export const backendReactor = new DisplayReactor<BackendService>({
+  clientManager,
+  idlFactory,
+  name: "backend",
+})
+"
+`;

package/src/generators/reactor.ts

@@ -1,8 +1,8 @@
 /**
  * Reactor File Generator
  *
- * Generates the managed `index.generated.ts` implementation for a canister
- * plus the full set of typed hooks via `createActorHooks`.
+ * Generates the managed `index.generated.ts` implementation for a canister.
+ * React targets also emit the full set of typed hooks via `createActorHooks`.
  *
  * Generated output example (for canister "backend"):
  *
@@ -22,7 +22,7 @@
 
 import path from "node:path"
 import { toPascalCase, getReactorName, getServiceTypeName } from "../naming.js"
-import type { ReactorClassName } from "../types.js"
+import type { CodegenTarget, ReactorClassName } from "../types.js"
 
 export interface ReactorGeneratorOptions {
   /** Canister name (e.g. "backend") */
@@ -39,6 +39,8 @@ export interface ReactorGeneratorOptions {
   clientManagerPath?: string
   /** Optional fixed canister ID for the generated reactor */
   canisterId?: string
+  /** Generated runtime target */
+  runtimeTarget?: CodegenTarget
   /**
    * Which reactor class should back the generated hooks.
    * Default: "DisplayReactor" (backward compatible)
@@ -47,12 +49,13 @@ export interface ReactorGeneratorOptions {
 }
 
 function getReactorClassImportSource(
-  reactorClass: ReactorClassName
-): "@ic-reactor/react" | "@ic-reactor/candid" {
+  reactorClass: ReactorClassName,
+  runtimeTarget: CodegenTarget
+): "@ic-reactor/react" | "@ic-reactor/core" | "@ic-reactor/candid" {
   switch (reactorClass) {
     case "Reactor":
     case "DisplayReactor":
-      return "@ic-reactor/react"
+      return runtimeTarget === "core" ? "@ic-reactor/core" : "@ic-reactor/react"
     case "CandidReactor":
     case "CandidDisplayReactor":
     case "MetadataDisplayReactor":
@@ -69,6 +72,7 @@ export function generateReactorFile(options: ReactorGeneratorOptions): string {
     didFile,
     clientManagerPath = "../../clients",
     canisterId,
+    runtimeTarget = "react",
     reactorClass = "DisplayReactor",
   } = options
 
@@ -79,13 +83,29 @@ export function generateReactorFile(options: ReactorGeneratorOptions): string {
   // Derive the declarations import path from the .did filename
   const baseName = path.basename(didFile, ".did")
   const declarationsPath = `./declarations/${baseName}`
-  const reactorImportSource = getReactorClassImportSource(reactorClass)
+  const reactorImportSource = getReactorClassImportSource(
+    reactorClass,
+    runtimeTarget
+  )
   const canisterIdLine = canisterId
     ? `  canisterId: ${JSON.stringify(canisterId)},\n`
     : ""
+  const hookExports =
+    runtimeTarget === "react"
+      ? `
 
-  return `import { createActorHooks } from "@ic-reactor/react"
-import { ${reactorClass} } from "${reactorImportSource}"
+export const {
+  useActorQuery: use${pascalName}Query,
+  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
+  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
+  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
+  useActorMutation: use${pascalName}Mutation,
+  useActorMethod: use${pascalName}Method,
+} = createActorHooks(${reactorName})
+`
+      : ""
+
+  return `${runtimeTarget === "react" ? 'import { createActorHooks } from "@ic-reactor/react"\n' : ""}import { ${reactorClass} } from "${reactorImportSource}"
 import { clientManager } from "${clientManagerPath}"
 import { idlFactory, type _SERVICE } from "${declarationsPath}"
 
@@ -101,17 +121,7 @@ export const ${reactorName} = new ${reactorClass}<${serviceName}>({
   clientManager,
   idlFactory,
 ${canisterIdLine}  name: "${canisterName}",
-})
-
-export const {
-  useActorQuery: use${pascalName}Query,
-  useActorSuspenseQuery: use${pascalName}SuspenseQuery,
-  useActorInfiniteQuery: use${pascalName}InfiniteQuery,
-  useActorSuspenseInfiniteQuery: use${pascalName}SuspenseInfiniteQuery,
-  useActorMutation: use${pascalName}Mutation,
-  useActorMethod: use${pascalName}Method,
-} = createActorHooks(${reactorName})
-`
+})${hookExports || "\n"}`
 }
 
 /**
@@ -122,7 +132,7 @@ export function generateReactorEntryFile(): string {
  * Canister entrypoint.
  *
  * Created once by @ic-reactor/codegen and safe to customize.
- * Keep the re-export below if you want generated hooks and types to stay in sync.
+ * Keep the re-export below if you want generated exports and types to stay in sync.
  */
 export * from "./index.generated"
 `

package/src/index.ts

@@ -9,6 +9,7 @@
 export type {
   CanisterConfig,
   CodegenConfig,
+  CodegenTarget,
   GeneratorResult,
   ReactorClassName,
 } from "./types.js"

package/src/pipeline.test.ts

@@ -95,6 +95,136 @@ describe("Codegen pipeline", () => {
     expect(generated).toContain('name: "workflow"')
   })
 
+  it("can generate declarations without creating reactor files", async () => {
+    const projectRoot = createTempProject()
+    writeDid(projectRoot, "backend.did")
+
+    const result = await runCanisterPipeline({
+      canisterConfig: {
+        name: "backend",
+        didFile: "backend.did",
+      },
+      projectRoot,
+      globalConfig: {
+        outDir: "src/declarations",
+        clientManagerPath: "../../clients",
+      },
+      generateReactor: false,
+    })
+
+    expect(result.success).toBe(true)
+    expect(
+      fs.existsSync(
+        path.join(
+          projectRoot,
+          "src/declarations/backend/declarations/backend.js"
+        )
+      )
+    ).toBe(true)
+    expect(
+      fs.existsSync(
+        path.join(
+          projectRoot,
+          "src/declarations/backend/declarations/backend.d.ts"
+        )
+      )
+    ).toBe(true)
+    expect(
+      fs.existsSync(
+        path.join(
+          projectRoot,
+          "src/declarations/backend/declarations/backend.did"
+        )
+      )
+    ).toBe(true)
+    expect(
+      fs.existsSync(
+        path.join(projectRoot, "src/declarations/backend/index.generated.ts")
+      )
+    ).toBe(false)
+    expect(
+      fs.existsSync(path.join(projectRoot, "src/declarations/backend/index.ts"))
+    ).toBe(false)
+    expect(
+      result.files.some((file) => file.filePath.endsWith("index.generated.ts"))
+    ).toBe(false)
+    expect(
+      result.files.some((file) => file.filePath.endsWith("index.ts"))
+    ).toBe(false)
+  })
+
+  it("leaves existing reactor files untouched when reactor generation is disabled", async () => {
+    const projectRoot = createTempProject()
+    writeDid(projectRoot, "backend.did")
+
+    const canisterOutDir = path.join(projectRoot, "src/declarations/backend")
+    fs.mkdirSync(canisterOutDir, { recursive: true })
+
+    const existingGenerated = "// existing generated reactor"
+    const existingEntry = "// existing entry wrapper"
+
+    fs.writeFileSync(
+      path.join(canisterOutDir, "index.generated.ts"),
+      existingGenerated
+    )
+    fs.writeFileSync(path.join(canisterOutDir, "index.ts"), existingEntry)
+
+    const result = await runCanisterPipeline({
+      canisterConfig: {
+        name: "backend",
+        didFile: "backend.did",
+      },
+      projectRoot,
+      globalConfig: {
+        outDir: "src/declarations",
+        clientManagerPath: "../../clients",
+      },
+      generateReactor: false,
+    })
+
+    expect(result.success).toBe(true)
+    expect(
+      fs.readFileSync(path.join(canisterOutDir, "index.generated.ts"), "utf-8")
+    ).toBe(existingGenerated)
+    expect(
+      fs.readFileSync(path.join(canisterOutDir, "index.ts"), "utf-8")
+    ).toBe(existingEntry)
+  })
+
+  it("supports a core target without generating React hooks", async () => {
+    const projectRoot = createTempProject()
+    writeDid(projectRoot, "backend.did")
+
+    const result = await runCanisterPipeline({
+      canisterConfig: {
+        name: "backend",
+        didFile: "backend.did",
+      },
+      projectRoot,
+      globalConfig: {
+        outDir: "src/declarations",
+        clientManagerPath: "../../clients",
+        target: "core",
+      },
+    })
+
+    expect(result.success).toBe(true)
+
+    const indexPath = path.join(
+      projectRoot,
+      "src/declarations/backend/index.generated.ts"
+    )
+    const generated = fs.readFileSync(indexPath, "utf-8")
+
+    expect(generated).toContain(
+      'import { DisplayReactor } from "@ic-reactor/core"'
+    )
+    expect(generated).not.toContain(
+      'import { createActorHooks } from "@ic-reactor/react"'
+    )
+    expect(generated).not.toContain("useBackendQuery")
+  })
+
   it("does not overwrite user-modified index.ts on regenerate", async () => {
     const projectRoot = createTempProject()
     writeDid(projectRoot, "backend.did")

package/src/pipeline.ts

@@ -7,8 +7,8 @@
  * Pipeline steps (in order):
  *  1. Resolve paths (didFile, outDir)
  *  2. Generate declarations (JS + .d.ts + .did copy)
- *  3. Generate reactor implementation (`index.generated.ts`)
- *  4. Create or migrate the user entry (`index.ts`)
+ *  3. Optionally generate reactor implementation (`index.generated.ts`)
+ *  4. Optionally create or migrate the user entry (`index.ts`)
  */
 
 import fs from "node:fs"
@@ -16,6 +16,7 @@ import path from "node:path"
 import type {
   CanisterConfig,
   CodegenConfig,
+  CodegenTarget,
   GeneratorResult,
   ReactorClassName,
 } from "./types.js"
@@ -36,13 +37,25 @@ export interface PipelineOptions {
   /**
    * Global codegen config (for fallback outDir and clientManagerPath).
    */
-  globalConfig: Pick<CodegenConfig, "outDir" | "clientManagerPath">
+  globalConfig: Pick<CodegenConfig, "outDir" | "clientManagerPath" | "target">
+  /**
+   * Whether the managed reactor files should be generated.
+   * Defaults to true.
+   */
+  generateReactor?: boolean
 }
 
 function resolveReactorClass(canisterConfig: CanisterConfig): ReactorClassName {
   return canisterConfig.mode ?? "DisplayReactor"
 }
 
+function resolveRuntimeTarget(
+  canisterConfig: CanisterConfig,
+  globalConfig: Pick<CodegenConfig, "outDir" | "clientManagerPath" | "target">
+): CodegenTarget {
+  return canisterConfig.target ?? globalConfig.target ?? "react"
+}
+
 function normalizeFileContent(content: string): string {
   return content.replace(/\r\n/g, "\n").trim()
 }
@@ -79,7 +92,12 @@ export interface PipelineResult {
 export async function runCanisterPipeline(
   options: PipelineOptions
 ): Promise<PipelineResult> {
-  const { canisterConfig, projectRoot, globalConfig } = options
+  const {
+    canisterConfig,
+    projectRoot,
+    globalConfig,
+    generateReactor = true,
+  } = options
   const { name, didFile, clientManagerPath } = canisterConfig
 
   const files: GeneratorResult[] = []
@@ -139,11 +157,20 @@ export async function runCanisterPipeline(
     }
   }
 
+  if (!generateReactor) {
+    return {
+      canisterName: name,
+      success: true,
+      files,
+    }
+  }
+
   // ── Step 2: Reactor file ───────────────────────────────────────────────────
 
   const reactorPath = path.join(canisterOutDir, "index.generated.ts")
   const entryPath = path.join(canisterOutDir, "index.ts")
   const reactorClass = resolveReactorClass(canisterConfig)
+  const runtimeTarget = resolveRuntimeTarget(canisterConfig, globalConfig)
 
   try {
     const reactorContent = generateReactorFile({
@@ -151,6 +178,7 @@ export async function runCanisterPipeline(
       didFile: resolvedDidFile,
       clientManagerPath: resolvedClientManagerPath,
       canisterId: canisterConfig.canisterId,
+      runtimeTarget,
       reactorClass,
     })
     const entryContent = generateReactorEntryFile()

package/src/reactor.test.ts

@@ -43,6 +43,24 @@ describe("Reactor generator", () => {
     expect(content).toContain("new MetadataDisplayReactor<LedgerService>")
   })
 
+  it("supports core target generation without React hooks", () => {
+    const content = generateReactorFile({
+      canisterName: "backend",
+      didFile: "mock/backend.did",
+      runtimeTarget: "core",
+      reactorClass: "DisplayReactor",
+    })
+
+    expect(content).toMatchSnapshot("core-display-reactor-index")
+    expect(content).toContain(
+      'import { DisplayReactor } from "@ic-reactor/core"'
+    )
+    expect(content).not.toContain(
+      'import { createActorHooks } from "@ic-reactor/react"'
+    )
+    expect(content).not.toContain("useBackendQuery")
+  })
+
   it("writes a fixed canisterId when configured", () => {
     const content = generateReactorFile({
       canisterName: "workflow",

package/src/types.ts

@@ -29,6 +29,11 @@ export interface CanisterConfig {
    * Defaults to DisplayReactor for backward compatibility.
    */
   mode?: ReactorClassName
+  /**
+   * Generated runtime target.
+   * `react` emits bound React hooks, `core` emits only the typed reactor exports.
+   */
+  target?: CodegenTarget
   /** Optional fixed canister ID */
   canisterId?: string
 }
@@ -40,6 +45,8 @@ export type ReactorClassName =
   | "CandidDisplayReactor"
   | "MetadataDisplayReactor"
 
+export type CodegenTarget = "react" | "core"
+
 /**
  * Top-level codegen / CLI configuration (stored in `ic-reactor.json`).
  */
@@ -56,6 +63,11 @@ export interface CodegenConfig {
    * Individual canisters can override via `CanisterConfig.clientManagerPath`.
    */
   clientManagerPath?: string
+  /**
+   * Default generated runtime target.
+   * Individual canisters can override via `CanisterConfig.target`.
+   */
+  target?: CodegenTarget
   /** Canister configurations, keyed by canister name */
   canisters: Record<string, CanisterConfig>
 }