@ic-reactor/codegen 0.7.2 → 0.9.0

package/README.md

@@ -24,7 +24,9 @@ await runCanisterPipeline({
   globalConfig: {
     outDir: "src/declarations",
     clientManagerPath: "../../clients",
+    target: "react",
   },
+  generateReactor: true,
 })
 ```
 
@@ -38,14 +40,23 @@ Set `canisterConfig.mode` to choose the generated reactor class:
 - `CandidDisplayReactor`
 - `MetadataDisplayReactor`
 
-Codegen writes a single `index.ts`. It overwrites that file only while it is still recognized as a generated file; if you replace it with your own file, regeneration leaves it untouched.
+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:
 
 - **`generateDeclarations`**: Generates `.js` (factory), `.d.ts` (types), and `.did` copy.
-- **`generateReactorFile`**: Generates the `index.ts` file using either `DisplayReactor` or `Reactor`.
+- **`generateReactorFile`**: Generates the managed `index.generated.ts` implementation using either `DisplayReactor` or `Reactor`.
+- **`generateReactorEntryFile`**: Generates the stable `index.ts` wrapper that re-exports from `index.generated.ts`.
 - **`generateClientFile`**: Generates a `ClientManager` boilerplate file.
 
 ## Utilities

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   extractMethods: () => extractMethods,
   generateClientFile: () => generateClientFile,
   generateDeclarations: () => generateDeclarations,
+  generateReactorEntryFile: () => generateReactorEntryFile,
   generateReactorFile: () => generateReactorFile,
   getReactorName: () => getReactorName,
   getServiceTypeName: () => getServiceTypeName,
@@ -123,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":
@@ -139,6 +140,8 @@ function generateReactorFile(options) {
     canisterName,
     didFile,
     clientManagerPath = "../../clients",
+    canisterId,
+    runtimeTarget = "react",
     reactorClass = "DisplayReactor"
   } = options;
   const pascalName = toPascalCase(canisterName);
@@ -146,9 +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);
-  return `import { createActorHooks } from "@ic-reactor/react"
-import { ${reactorClass} } from "${reactorImportSource}"
+  const reactorImportSource = getReactorClassImportSource(
+    reactorClass,
+    runtimeTarget
+  );
+  const canisterIdLine = canisterId ? `  canisterId: ${JSON.stringify(canisterId)},
+` : "";
+  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}"
 
@@ -158,22 +176,22 @@ export type ${serviceName} = _SERVICE
  * ${pascalName} Reactor
  *
  * Auto-generated by @ic-reactor/codegen \u2014 do not edit.
- * Re-run \`ic-reactor generate\` (or the Vite plugin) to regenerate.
+ * This file is overwritten whenever generation runs.
  */
 export const ${reactorName} = new ${reactorClass}<${serviceName}>({
   clientManager,
   idlFactory,
-  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})
+${canisterIdLine}  name: "${canisterName}",
+})${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 exports and types to stay in sync.
+ */
+export * from "./index.generated"
 `;
 }
 
@@ -181,11 +199,25 @@ export const {
 function resolveReactorClass(canisterConfig) {
   return canisterConfig.mode ?? "DisplayReactor";
 }
-function isGeneratedIndexFile(content) {
+function resolveRuntimeTarget(canisterConfig, globalConfig) {
+  return canisterConfig.target ?? globalConfig.target ?? "react";
+}
+function normalizeFileContent(content) {
+  return content.replace(/\r\n/g, "\n").trim();
+}
+function isLegacyGeneratedIndexFile(content) {
   return content.includes("Auto-generated by @ic-reactor/codegen") && content.includes("createActorHooks(");
 }
+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);
@@ -222,26 +254,40 @@ async function runCanisterPipeline(options) {
       error: `Declarations step failed: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const reactorPath = import_node_path3.default.join(canisterOutDir, "index.ts");
+  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();
     import_node_fs2.default.mkdirSync(canisterOutDir, { recursive: true });
-    if (!import_node_fs2.default.existsSync(reactorPath)) {
-      import_node_fs2.default.writeFileSync(reactorPath, reactorContent);
-      files.push({ success: true, filePath: reactorPath });
+    import_node_fs2.default.writeFileSync(reactorPath, reactorContent);
+    files.push({ success: true, filePath: reactorPath });
+    if (!import_node_fs2.default.existsSync(entryPath)) {
+      import_node_fs2.default.writeFileSync(entryPath, entryContent);
+      files.push({ success: true, filePath: entryPath });
     } else {
-      const existingIndexContent = import_node_fs2.default.readFileSync(reactorPath, "utf-8");
-      if (isGeneratedIndexFile(existingIndexContent)) {
-        import_node_fs2.default.writeFileSync(reactorPath, reactorContent);
-        files.push({ success: true, filePath: reactorPath });
+      const existingEntryContent = import_node_fs2.default.readFileSync(entryPath, "utf-8");
+      if (isLegacyGeneratedIndexFile(existingEntryContent) || isManagedEntryWrapper(existingEntryContent, entryContent)) {
+        import_node_fs2.default.writeFileSync(entryPath, entryContent);
+        files.push({ success: true, filePath: entryPath });
       } else {
-        files.push({ success: true, filePath: reactorPath, skipped: true });
+        files.push({ success: true, filePath: entryPath, skipped: true });
       }
     }
   } catch (err) {
@@ -325,6 +371,7 @@ export const clientManager = new ClientManager({
   extractMethods,
   generateClientFile,
   generateDeclarations,
+  generateReactorEntryFile,
   generateReactorFile,
   getReactorName,
   getServiceTypeName,

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,7 +79,8 @@ interface GeneratorResult {
  * Pipeline steps (in order):
  *  1. Resolve paths (didFile, outDir)
  *  2. Generate declarations (JS + .d.ts + .did copy)
- *  3. Generate reactor file (`index.ts`)
+ *  3. Optionally generate reactor implementation (`index.generated.ts`)
+ *  4. Optionally create or migrate the user entry (`index.ts`)
  */
 
 interface PipelineOptions {
@@ -82,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;
@@ -192,8 +209,8 @@ declare function declarationsExist(outDir: string, canisterName: string): boolea
 /**
  * Reactor File Generator
  *
- * Generates the main `index.ts` for a canister — a DisplayReactor instance
- * 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"):
  *
@@ -224,6 +241,10 @@ interface ReactorGeneratorOptions {
      * Default: "../../clients"
      */
     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)
@@ -231,9 +252,13 @@ interface ReactorGeneratorOptions {
     reactorClass?: ReactorClassName;
 }
 /**
- * Generate the content of a canister's `index.ts` file.
+ * Generate the content of a canister's managed implementation file.
  */
 declare function generateReactorFile(options: ReactorGeneratorOptions): string;
+/**
+ * Generate the user-facing `index.ts` wrapper content.
+ */
+declare function generateReactorEntryFile(): string;
 
 /**
  * Client Manager Generator
@@ -258,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, 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,7 +79,8 @@ interface GeneratorResult {
  * Pipeline steps (in order):
  *  1. Resolve paths (didFile, outDir)
  *  2. Generate declarations (JS + .d.ts + .did copy)
- *  3. Generate reactor file (`index.ts`)
+ *  3. Optionally generate reactor implementation (`index.generated.ts`)
+ *  4. Optionally create or migrate the user entry (`index.ts`)
  */
 
 interface PipelineOptions {
@@ -82,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;
@@ -192,8 +209,8 @@ declare function declarationsExist(outDir: string, canisterName: string): boolea
 /**
  * Reactor File Generator
  *
- * Generates the main `index.ts` for a canister — a DisplayReactor instance
- * 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"):
  *
@@ -224,6 +241,10 @@ interface ReactorGeneratorOptions {
      * Default: "../../clients"
      */
     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)
@@ -231,9 +252,13 @@ interface ReactorGeneratorOptions {
     reactorClass?: ReactorClassName;
 }
 /**
- * Generate the content of a canister's `index.ts` file.
+ * Generate the content of a canister's managed implementation file.
  */
 declare function generateReactorFile(options: ReactorGeneratorOptions): string;
+/**
+ * Generate the user-facing `index.ts` wrapper content.
+ */
+declare function generateReactorEntryFile(): string;
 
 /**
  * Client Manager Generator
@@ -258,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, 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":
@@ -94,6 +94,8 @@ function generateReactorFile(options) {
     canisterName,
     didFile,
     clientManagerPath = "../../clients",
+    canisterId,
+    runtimeTarget = "react",
     reactorClass = "DisplayReactor"
   } = options;
   const pascalName = toPascalCase(canisterName);
@@ -101,9 +103,24 @@ function generateReactorFile(options) {
   const serviceName = getServiceTypeName(canisterName);
   const baseName = path2.basename(didFile, ".did");
   const declarationsPath = `./declarations/${baseName}`;
-  const reactorImportSource = getReactorClassImportSource(reactorClass);
-  return `import { createActorHooks } from "@ic-reactor/react"
-import { ${reactorClass} } from "${reactorImportSource}"
+  const reactorImportSource = getReactorClassImportSource(
+    reactorClass,
+    runtimeTarget
+  );
+  const canisterIdLine = canisterId ? `  canisterId: ${JSON.stringify(canisterId)},
+` : "";
+  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}"
 
@@ -113,22 +130,22 @@ export type ${serviceName} = _SERVICE
  * ${pascalName} Reactor
  *
  * Auto-generated by @ic-reactor/codegen \u2014 do not edit.
- * Re-run \`ic-reactor generate\` (or the Vite plugin) to regenerate.
+ * This file is overwritten whenever generation runs.
  */
 export const ${reactorName} = new ${reactorClass}<${serviceName}>({
   clientManager,
   idlFactory,
-  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})
+${canisterIdLine}  name: "${canisterName}",
+})${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 exports and types to stay in sync.
+ */
+export * from "./index.generated"
 `;
 }
 
@@ -136,11 +153,25 @@ export const {
 function resolveReactorClass(canisterConfig) {
   return canisterConfig.mode ?? "DisplayReactor";
 }
-function isGeneratedIndexFile(content) {
+function resolveRuntimeTarget(canisterConfig, globalConfig) {
+  return canisterConfig.target ?? globalConfig.target ?? "react";
+}
+function normalizeFileContent(content) {
+  return content.replace(/\r\n/g, "\n").trim();
+}
+function isLegacyGeneratedIndexFile(content) {
   return content.includes("Auto-generated by @ic-reactor/codegen") && content.includes("createActorHooks(");
 }
+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);
@@ -177,26 +208,40 @@ async function runCanisterPipeline(options) {
       error: `Declarations step failed: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const reactorPath = path3.join(canisterOutDir, "index.ts");
+  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();
     fs2.mkdirSync(canisterOutDir, { recursive: true });
-    if (!fs2.existsSync(reactorPath)) {
-      fs2.writeFileSync(reactorPath, reactorContent);
-      files.push({ success: true, filePath: reactorPath });
+    fs2.writeFileSync(reactorPath, reactorContent);
+    files.push({ success: true, filePath: reactorPath });
+    if (!fs2.existsSync(entryPath)) {
+      fs2.writeFileSync(entryPath, entryContent);
+      files.push({ success: true, filePath: entryPath });
     } else {
-      const existingIndexContent = fs2.readFileSync(reactorPath, "utf-8");
-      if (isGeneratedIndexFile(existingIndexContent)) {
-        fs2.writeFileSync(reactorPath, reactorContent);
-        files.push({ success: true, filePath: reactorPath });
+      const existingEntryContent = fs2.readFileSync(entryPath, "utf-8");
+      if (isLegacyGeneratedIndexFile(existingEntryContent) || isManagedEntryWrapper(existingEntryContent, entryContent)) {
+        fs2.writeFileSync(entryPath, entryContent);
+        files.push({ success: true, filePath: entryPath });
       } else {
-        files.push({ success: true, filePath: reactorPath, skipped: true });
+        files.push({ success: true, filePath: entryPath, skipped: true });
       }
     }
   } catch (err) {
@@ -279,6 +324,7 @@ export {
   extractMethods,
   generateClientFile,
   generateDeclarations,
+  generateReactorEntryFile,
   generateReactorFile,
   getReactorName,
   getServiceTypeName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/codegen",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Shared code generation utilities for IC Reactor",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -37,7 +37,7 @@
     "@ic-reactor/parser": "0.4.6"
   },
   "devDependencies": {
-    "@types/node": "^25.3.0",
+    "@types/node": "^25.3.5",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"

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

@@ -12,7 +12,7 @@ export type BackendService = _SERVICE
  * Backend Reactor
  *
  * Auto-generated by @ic-reactor/codegen — do not edit.
- * Re-run \`ic-reactor generate\` (or the Vite plugin) to regenerate.
+ * This file is overwritten whenever generation runs.
  */
 export const backendReactor = new DisplayReactor<BackendService>({
   clientManager,
@@ -43,7 +43,7 @@ export type WorkflowEngineService = _SERVICE
  * WorkflowEngine Reactor
  *
  * Auto-generated by @ic-reactor/codegen — do not edit.
- * Re-run \`ic-reactor generate\` (or the Vite plugin) to regenerate.
+ * This file is overwritten whenever generation runs.
  */
 export const workflowEngineReactor = new Reactor<WorkflowEngineService>({
   clientManager,
@@ -74,7 +74,7 @@ export type LedgerService = _SERVICE
  * Ledger Reactor
  *
  * Auto-generated by @ic-reactor/codegen — do not edit.
- * Re-run \`ic-reactor generate\` (or the Vite plugin) to regenerate.
+ * This file is overwritten whenever generation runs.
  */
 export const ledgerReactor = new MetadataDisplayReactor<LedgerService>({
   clientManager,
@@ -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/index.ts

@@ -11,7 +11,7 @@ export type {
   DeclarationsGeneratorResult,
 } from "./declarations.js"
 
-export { generateReactorFile } from "./reactor.js"
+export { generateReactorFile, generateReactorEntryFile } from "./reactor.js"
 export type { ReactorGeneratorOptions } from "./reactor.js"
 
 export { generateClientFile } from "./client.js"

package/src/generators/reactor.ts

@@ -1,8 +1,8 @@
 /**
  * Reactor File Generator
  *
- * Generates the main `index.ts` for a canister — a DisplayReactor instance
- * 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") */
@@ -37,6 +37,10 @@ export interface ReactorGeneratorOptions {
    * Default: "../../clients"
    */
   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)
@@ -45,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":
@@ -59,13 +64,15 @@ function getReactorClassImportSource(
 }
 
 /**
- * Generate the content of a canister's `index.ts` file.
+ * Generate the content of a canister's managed implementation file.
  */
 export function generateReactorFile(options: ReactorGeneratorOptions): string {
   const {
     canisterName,
     didFile,
     clientManagerPath = "../../clients",
+    canisterId,
+    runtimeTarget = "react",
     reactorClass = "DisplayReactor",
   } = options
 
@@ -76,10 +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}"
 
@@ -89,21 +115,25 @@ export type ${serviceName} = _SERVICE
  * ${pascalName} Reactor
  *
  * Auto-generated by @ic-reactor/codegen — do not edit.
- * Re-run \`ic-reactor generate\` (or the Vite plugin) to regenerate.
+ * This file is overwritten whenever generation runs.
  */
 export const ${reactorName} = new ${reactorClass}<${serviceName}>({
   clientManager,
   idlFactory,
-  name: "${canisterName}",
-})
+${canisterIdLine}  name: "${canisterName}",
+})${hookExports || "\n"}`
+}
 
-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})
+/**
+ * Generate the user-facing `index.ts` wrapper content.
+ */
+export function generateReactorEntryFile(): string {
+  return `/**
+ * Canister entrypoint.
+ *
+ * Created once by @ic-reactor/codegen and safe to customize.
+ * 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

@@ -52,12 +52,177 @@ describe("Codegen pipeline", () => {
 
     const indexPath = path.join(
       projectRoot,
-      "src/declarations/workflow_engine/index.ts"
+      "src/declarations/workflow_engine/index.generated.ts"
     )
     const generated = fs.readFileSync(indexPath, "utf-8")
 
     expect(generated).toContain("new Reactor<WorkflowEngineService>")
     expect(generated).not.toContain("new DisplayReactor<WorkflowEngineService>")
+    expect(
+      fs.readFileSync(
+        path.join(projectRoot, "src/declarations/workflow_engine/index.ts"),
+        "utf-8"
+      )
+    ).toContain('export * from "./index.generated"')
+  })
+
+  it("writes a configured canisterId into the generated reactor", async () => {
+    const projectRoot = createTempProject()
+    writeDid(projectRoot, "workflow.did")
+
+    const result = await runCanisterPipeline({
+      canisterConfig: {
+        name: "workflow",
+        didFile: "workflow.did",
+        canisterId: "yq4ns-hyaaa-aaaap-akbna-cai",
+      },
+      projectRoot,
+      globalConfig: {
+        outDir: "src/declarations",
+        clientManagerPath: "../../clients",
+      },
+    })
+
+    expect(result.success).toBe(true)
+
+    const indexPath = path.join(
+      projectRoot,
+      "src/declarations/workflow/index.generated.ts"
+    )
+    const generated = fs.readFileSync(indexPath, "utf-8")
+
+    expect(generated).toContain('canisterId: "yq4ns-hyaaa-aaaap-akbna-cai"')
+    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 () => {
@@ -90,11 +255,22 @@ export const customBackendIndex = true
 `
     )
 
-    const second = await runCanisterPipeline(options)
+    const second = await runCanisterPipeline({
+      ...options,
+      canisterConfig: {
+        ...options.canisterConfig,
+        canisterId: "yq4ns-hyaaa-aaaap-akbna-cai",
+      },
+    })
     expect(second.success).toBe(true)
 
     const wrapper = fs.readFileSync(indexPath, "utf-8")
     expect(wrapper).toContain("customBackendIndex = true")
+    const generatedImpl = fs.readFileSync(
+      path.join(projectRoot, "src/declarations/backend/index.generated.ts"),
+      "utf-8"
+    )
+    expect(generatedImpl).toContain('canisterId: "yq4ns-hyaaa-aaaap-akbna-cai"')
     expect(second.files).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
@@ -106,17 +282,14 @@ export const customBackendIndex = true
     )
   })
 
-  it("overwrites legacy generated index.ts during regeneration", async () => {
+  it("migrates a legacy generated index.ts to the managed wrapper", async () => {
     const projectRoot = createTempProject()
     writeDid(projectRoot, "backend.did")
 
     const canisterOutDir = path.join(projectRoot, "src/declarations/backend")
     fs.mkdirSync(canisterOutDir, { recursive: true })
 
-    // Simulate a generated index.ts content from older versions.
-    fs.writeFileSync(
-      path.join(canisterOutDir, "index.ts"),
-      `import { DisplayReactor, createActorHooks } from "@ic-reactor/react"
+    const existingGeneratedIndex = `import { DisplayReactor, createActorHooks } from "@ic-reactor/react"
 import { clientManager } from "../../clients"
 import { idlFactory, type _SERVICE } from "./declarations/backend"
 
@@ -126,7 +299,6 @@ export type BackendService = _SERVICE
  * Backend Reactor
  *
  * Auto-generated by @ic-reactor/codegen — do not edit.
- * Re-run \`ic-reactor generate\` (or the Vite plugin) to regenerate.
  */
 export const backendReactor = new DisplayReactor<BackendService>({
   clientManager,
@@ -138,6 +310,9 @@ export const {
   useActorQuery: useBackendQuery,
 } = createActorHooks(backendReactor)
 `
+    fs.writeFileSync(
+      path.join(canisterOutDir, "index.ts"),
+      existingGeneratedIndex
     )
 
     const result = await runCanisterPipeline({
@@ -155,9 +330,26 @@ export const {
     expect(result.success).toBe(true)
 
     const indexPath = path.join(canisterOutDir, "index.ts")
-    const generated = fs.readFileSync(indexPath, "utf-8")
+    const entry = fs.readFileSync(indexPath, "utf-8")
+    const generated = fs.readFileSync(
+      path.join(canisterOutDir, "index.generated.ts"),
+      "utf-8"
+    )
+    expect(entry).toContain('export * from "./index.generated"')
+    expect(entry).not.toBe(existingGeneratedIndex)
     expect(generated).toContain("new DisplayReactor<BackendService>")
     expect(generated).toContain("useBackendMutation")
-    expect(generated).not.toContain('export * from "./index.generated"')
+    expect(result.files).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          filePath: path.join(canisterOutDir, "index.generated.ts"),
+          success: true,
+        }),
+        expect.objectContaining({
+          filePath: indexPath,
+          success: true,
+        }),
+      ])
+    )
   })
 })

package/src/pipeline.ts

@@ -7,7 +7,8 @@
  * Pipeline steps (in order):
  *  1. Resolve paths (didFile, outDir)
  *  2. Generate declarations (JS + .d.ts + .did copy)
- *  3. Generate reactor file (`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"
@@ -15,11 +16,15 @@ import path from "node:path"
 import type {
   CanisterConfig,
   CodegenConfig,
+  CodegenTarget,
   GeneratorResult,
   ReactorClassName,
 } from "./types.js"
 import { generateDeclarations } from "./generators/declarations.js"
-import { generateReactorFile } from "./generators/reactor.js"
+import {
+  generateReactorEntryFile,
+  generateReactorFile,
+} from "./generators/reactor.js"
 
 export interface PipelineOptions {
   /** Canister name and config */
@@ -32,20 +37,45 @@ 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 isGeneratedIndexFile(content: string): boolean {
+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()
+}
+
+function isLegacyGeneratedIndexFile(content: string): boolean {
   return (
     content.includes("Auto-generated by @ic-reactor/codegen") &&
     content.includes("createActorHooks(")
   )
 }
 
+function isManagedEntryWrapper(
+  content: string,
+  expectedEntryContent: string
+): boolean {
+  return (
+    normalizeFileContent(content) === normalizeFileContent(expectedEntryContent)
+  )
+}
+
 export interface PipelineResult {
   canisterName: string
   success: boolean
@@ -62,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[] = []
@@ -122,31 +157,50 @@ export async function runCanisterPipeline(
     }
   }
 
+  if (!generateReactor) {
+    return {
+      canisterName: name,
+      success: true,
+      files,
+    }
+  }
+
   // ── Step 2: Reactor file ───────────────────────────────────────────────────
 
-  const reactorPath = path.join(canisterOutDir, "index.ts")
+  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({
       canisterName: name,
       didFile: resolvedDidFile,
       clientManagerPath: resolvedClientManagerPath,
+      canisterId: canisterConfig.canisterId,
+      runtimeTarget,
       reactorClass,
     })
+    const entryContent = generateReactorEntryFile()
 
     fs.mkdirSync(canisterOutDir, { recursive: true })
-    if (!fs.existsSync(reactorPath)) {
-      fs.writeFileSync(reactorPath, reactorContent)
-      files.push({ success: true, filePath: reactorPath })
-    } else {
-      const existingIndexContent = fs.readFileSync(reactorPath, "utf-8")
+    fs.writeFileSync(reactorPath, reactorContent)
+    files.push({ success: true, filePath: reactorPath })
 
-      if (isGeneratedIndexFile(existingIndexContent)) {
-        fs.writeFileSync(reactorPath, reactorContent)
-        files.push({ success: true, filePath: reactorPath })
+    if (!fs.existsSync(entryPath)) {
+      fs.writeFileSync(entryPath, entryContent)
+      files.push({ success: true, filePath: entryPath })
+    } else {
+      const existingEntryContent = fs.readFileSync(entryPath, "utf-8")
+
+      if (
+        isLegacyGeneratedIndexFile(existingEntryContent) ||
+        isManagedEntryWrapper(existingEntryContent, entryContent)
+      ) {
+        fs.writeFileSync(entryPath, entryContent)
+        files.push({ success: true, filePath: entryPath })
       } else {
-        files.push({ success: true, filePath: reactorPath, skipped: true })
+        files.push({ success: true, filePath: entryPath, skipped: true })
       }
     }
   } catch (err) {

package/src/reactor.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest"
-import { generateReactorFile } from "./generators"
+import { generateReactorEntryFile, generateReactorFile } from "./generators"
 
 describe("Reactor generator", () => {
   it("keeps default behavior as DisplayReactor", () => {
@@ -42,4 +42,40 @@ 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",
+      didFile: "mock/workflow.did",
+      canisterId: "yq4ns-hyaaa-aaaap-akbna-cai",
+    })
+
+    expect(content).toContain('canisterId: "yq4ns-hyaaa-aaaap-akbna-cai"')
+    expect(content).toContain('name: "workflow"')
+  })
+
+  it("generates a stable entry wrapper", () => {
+    const content = generateReactorEntryFile()
+
+    expect(content).toContain('export * from "./index.generated"')
+    expect(content).toContain("safe to customize")
+  })
 })

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>
 }