@mayson-org/inject-script 1.0.0 → 1.0.3

package/.env.example

@@ -0,0 +1,9 @@
+# Set before running inject-script (e.g. in CI / Vercel build env)
+
+MAYSON_WORKSPACE_ID=
+MAYSON_COLLECTION_ID=
+MAYSON_API_BASE_URL=
+MAYSON_APP_BASE_URL=https://mayson.dev
+
+# Auth for generated-app-metadata (show_remix_pill / enable_remix)
+MAYSON_WEB_TOKEN=

package/README.md

@@ -1,71 +1,83 @@
-# @mayson/inject-script
+# @mayson-org/inject-script
 
-A lightweight CLI tool and Node.js package designed for **Next.js App Router** applications. It dynamically locates the project's root layout file (regardless of whether it's stored in `app/layout.tsx`, `src/app/layout.tsx`, or inside route groups like `app/(main)/layout.js`) and injects a floating `<iframe>` pointing to `https://mayson.dev/`.
+Locate the Next.js App Router root layout, generate Mayson plugin components next to it, and inject imports + JSX into the layout. Injection logic is unchanged; plugins supply component source.
 
----
+Requires **Node 20+**.
 
-## Quick Usage via `npx`
-
-Run directly in any Next.js project root:
+## Install
 
 ```bash
-npx @mayson/inject-script
+bun add -d @mayson-org/inject-script@latest
+# or
+npx @mayson-org/inject-script --type=watermark
 ```
 
-Or pass optional flags:
+## Quick usage
 
 ```bash
-# Specify custom iframe URL
-npx @mayson/inject-script --url=https://mayson.dev/my-app
+npx @mayson-org/inject-script --type=watermark
+npx @mayson-org/inject-script --type=all
+npx @mayson-org/inject-script --type=watermark --dry-run
+npx @mayson-org/inject-script --dir=./my-app --type=watermark
+```
 
-# Dry-run mode (preview changes without modifying files)
-npx @mayson/inject-script --dry-run
+## Watermark
 
-# Specify target project directory
-npx @mayson/inject-script --dir=./my-nextjs-app
-```
+`--type=watermark` writes `MaysonWatermark.tsx` beside the root layout and injects `<MaysonWatermark />` before `</body>`.
 
----
+The pill:
 
-## Adding to Next.js `package.json` Build Scripts
+- Fixed bottom-right “Edit with Mayson” (logo + label)
+- Dismiss (×) hides it for the session
+- Click opens the Mayson remix URL (baked at inject time)
 
-You can automate this script during deployment builds (e.g. on Vercel, Netlify, Docker, or GitHub Actions) by adding it to `package.json`:
+### API gating (`show_remix_pill` / `enable_remix`)
 
-```json
-{
-  "scripts": {
-    "dev": "next dev",
-    "prebuild": "npx @mayson/inject-script",
-    "build": "next build"
-  }
-}
-```
+At inject time the CLI fetches **generated-app-metadata** (same API as the old build plugins):
 
----
+`GET {MAYSON_API_BASE_URL}/sigma/web/v1/generated-app-metadata/workspaces/{id}/collections/{id}`  
+Header: `M-Web-Token: {MAYSON_WEB_TOKEN}`
 
-## Programmatic API Usage
+| API field | Effect |
+|-----------|--------|
+| `show_remix_pill` | If `false`, watermark is **not** injected; if `true`, inject |
+| `enable_remix` | Baked into the component remix URL (`true` → collection remix redirect; otherwise app home) |
 
-You can also import and use `inject-script` in custom build scripts:
+**Metadata not found (404):** if the API returns HTTP 404 or a body like `{ "response_code": 404, "message": "Generated app metadata not found", "value": {} }`, treat as **`show_remix_pill=true`** and **`enable_remix=true`** (show watermark, remixable).
 
-```javascript
-import { runAutoInject, findRootLayout, injectMaysonIframe } from 'inject-script';
+Defaults when the API is not called or fails for other reasons: `showRemixPill=false`, `enableRemix=false` (watermark skipped).
 
-// 1. Auto-detect and inject in one call
-const result = runAutoInject(process.cwd(), 'https://mayson.dev/');
+### Env vars (inject-time)
 
-if (result.success) {
-  console.log(`Injected to: ${result.filePath}`);
-}
+| Variable | Purpose |
+|----------|---------|
+| `MAYSON_WORKSPACE_ID` | Workspace id |
+| `MAYSON_COLLECTION_ID` | Collection id (also baked into remix URL) |
+| `MAYSON_API_BASE_URL` | API base for metadata |
+| `MAYSON_APP_BASE_URL` | App base (default `https://mayson.dev`) |
+| `MAYSON_WEB_TOKEN` | Auth for generated-app-metadata |
 
-// 2. Or manually find layout and inspect
-const rootLayoutPath = findRootLayout('./my-project');
-console.log('Root Layout found at:', rootLayoutPath);
+## Programmatic API
+
+```ts
+import { runAutoInject } from '@mayson-org/inject-script';
+
+const result = await runAutoInject(process.cwd(), ['watermark']);
 ```
 
----
+## Package layout
+
+```text
+src/
+  cli.ts / index.ts
+  core/                  # find-root-layout, injector, generators
+  plugins/watermark/     # remix pill template
+  plugins/ascii|metadata # stubs for later restores
+  shared/                # config, generated-app-metadata, remix-url
+```
 
-## Features
+## Notes
 
-- 🔍 **Dynamic Root Layout Resolution**: Scans `app/`, `src/app/`, and nested route groups for layout files and scores candidates based on HTML/Body root tags.
-- ⚡ **Idempotent**: Safe to run multiple times without creating duplicate iframe injections.
-- 🛡️ **Zero Runtime Overhead**: Inserts a self-contained React `<iframe />` directly into the JSX tree.
+- Default `--type` is `watermark`.
+- Idempotent: skips components already present in the layout.
+- Does not patch `.next` HTML; source inject only.

package/bin/cli.mjs

@@ -1,159 +1,2 @@
 #!/usr/bin/env node
-
-import fs from 'fs';
-import path from 'path';
-
-function findLayoutFiles(dir, fileList = []) {
-  if (!fs.existsSync(dir)) return fileList;
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
-      findLayoutFiles(fullPath, fileList);
-    } else if (entry.isFile()) {
-      const ext = path.extname(entry.name);
-      const base = path.basename(entry.name, ext);
-      if (base === 'layout' && ['.tsx', '.jsx', '.ts', '.js'].includes(ext)) {
-        fileList.push(fullPath);
-      }
-    }
-  }
-  return fileList;
-}
-
-function scoreLayout(filePath, projectRoot) {
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const relativePath = path.relative(projectRoot, filePath);
-  const depth = relativePath.split(path.sep).length;
-  let score = 100 - depth;
-
-  if (/<html/i.test(content)) score += 50;
-  if (/<body/i.test(content)) score += 50;
-  if (/^src[/\\]app[/\\]layout\.[jt]sx?$/.test(relativePath) || /^app[/\\]layout\.[jt]sx?$/.test(relativePath)) {
-    score += 40;
-  }
-  return score;
-}
-
-function findRootLayout(projectRoot) {
-  const possibleDirs = [path.join(projectRoot, 'src', 'app'), path.join(projectRoot, 'app')];
-  const candidates = [];
-
-  for (const dir of possibleDirs) {
-    if (fs.existsSync(dir)) findLayoutFiles(dir, candidates);
-  }
-
-  if (candidates.length === 0) return null;
-  candidates.sort((a, b) => scoreLayout(b, projectRoot) - scoreLayout(a, projectRoot));
-  return candidates[0];
-}
-
-function parseArgs() {
-  const args = process.argv.slice(2);
-  const options = {
-    projectRoot: process.cwd(),
-    url: 'https://mayson.dev/',
-    dryRun: false,
-    help: false,
-  };
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '--help' || arg === '-h') {
-      options.help = true;
-    } else if (arg === '--dry-run') {
-      options.dryRun = true;
-    } else if (arg.startsWith('--url=')) {
-      options.url = arg.split('=')[1];
-    } else if (arg === '--url' && args[i + 1]) {
-      options.url = args[++i];
-    } else if (arg.startsWith('--dir=')) {
-      options.projectRoot = path.resolve(arg.split('=')[1]);
-    } else if (arg === '--dir' && args[i + 1]) {
-      options.projectRoot = path.resolve(args[++i]);
-    }
-  }
-  return options;
-}
-
-const options = parseArgs();
-
-if (options.help) {
-  console.log(`
-Inject Script CLI - Next.js App Router Root Layout Iframe Injector
-
-Usage:
-  npx inject-script [options]
-
-Options:
-  --dir <path>       Target project root directory (default: current working directory)
-  --url <url>        Iframe URL to inject (default: https://mayson.dev/)
-  --dry-run          Simulate layout detection and code injection without modifying files
-  --help, -h         Show this help message
-`);
-  process.exit(0);
-}
-
-console.log(`🔍 Searching for Next.js root layout in: ${options.projectRoot}`);
-
-const layoutFile = findRootLayout(options.projectRoot);
-
-if (!layoutFile) {
-  console.error(`❌ Error: Could not find any App Router layout file in ${options.projectRoot}`);
-  process.exit(1);
-}
-
-console.log(`📍 Found Root Layout: ${path.relative(options.projectRoot, layoutFile)}`);
-
-const content = fs.readFileSync(layoutFile, 'utf-8');
-const INJECTION_MARKER = '/* @mayson-iframe-injected */';
-
-if (content.includes(INJECTION_MARKER) || content.includes(options.url)) {
-  console.log(`✅ Mayson iframe is already injected in ${path.basename(layoutFile)}.`);
-  process.exit(0);
-}
-
-const snippet = `
-      {${INJECTION_MARKER}}
-      <iframe
-        src="${options.url}"
-        style={{
-          position: 'fixed',
-          bottom: '20px',
-          right: '20px',
-          width: '400px',
-          height: '600px',
-          border: 'none',
-          borderRadius: '12px',
-          boxShadow: '0 8px 32px rgba(0, 0, 0, 0.25)',
-          zIndex: 999999,
-        }}
-        title="Mayson Dev Overlay"
-      />`;
-
-let updatedContent = null;
-
-if (/<\/body>/i.test(content)) {
-  updatedContent = content.replace(/<\/body>/i, `${snippet}\n      </body>`);
-} else if (/<\/html>/i.test(content)) {
-  updatedContent = content.replace(/<\/html>/i, `${snippet}\n      </html>`);
-} else {
-  const lastIndex = content.lastIndexOf('</');
-  if (lastIndex !== -1) {
-    updatedContent = content.slice(0, lastIndex) + snippet + '\n      ' + content.slice(lastIndex);
-  }
-}
-
-if (!updatedContent) {
-  console.error(`❌ Error: Could not find suitable insertion point in ${layoutFile}`);
-  process.exit(1);
-}
-
-if (options.dryRun) {
-  console.log(`🧪 [Dry Run] Would inject iframe to ${layoutFile}`);
-} else {
-  fs.writeFileSync(layoutFile, updatedContent, 'utf-8');
-  console.log(`🎉 Successfully injected Mayson iframe (${options.url}) into ${path.relative(options.projectRoot, layoutFile)}!`);
-}
+import '../dist/cli.js';

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): Promise<void>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAwDA,wBAAsB,IAAI,CAAC,IAAI,WAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6DtE"}

package/dist/cli.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { runAutoInject } from './index.js';
+function printHelp() {
+    console.log(`
+@mayson-org/inject-script — generate & inject Mayson components into Next.js App Router layout
+
+Usage:
+  inject-script [options]
+  npx @mayson-org/inject-script [options]
+
+Options:
+  --dir <path>       Target project root (default: cwd)
+  --type <type>      watermark | ascii | metadata | all (default: watermark)
+  --dry-run          Preview without writing files
+  --help, -h         Show help
+
+Watermark gating (inject-time):
+  Fetches generated-app-metadata when MAYSON_WORKSPACE_ID, MAYSON_COLLECTION_ID,
+  MAYSON_API_BASE_URL, and MAYSON_WEB_TOKEN are set. Injects watermark only when
+  show_remix_pill is true; bakes enable_remix into the generated component.
+`);
+}
+function parseArgs(argv) {
+    const options = {
+        projectRoot: process.cwd(),
+        type: 'watermark',
+        dryRun: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            options.help = true;
+        }
+        else if (arg === '--dry-run') {
+            options.dryRun = true;
+        }
+        else if (arg.startsWith('--type=')) {
+            options.type = arg.split('=')[1];
+        }
+        else if (arg === '--type' && argv[i + 1]) {
+            options.type = argv[++i];
+        }
+        else if (arg.startsWith('--dir=')) {
+            options.projectRoot = path.resolve(arg.split('=')[1]);
+        }
+        else if (arg === '--dir' && argv[i + 1]) {
+            options.projectRoot = path.resolve(argv[++i]);
+        }
+        else {
+            throw new Error(`unknown argument: ${arg}`);
+        }
+    }
+    return options;
+}
+export async function main(argv = process.argv.slice(2)) {
+    try {
+        const options = parseArgs(argv);
+        if (options.help) {
+            printHelp();
+            return;
+        }
+        console.log(`Searching for Next.js root layout in: ${options.projectRoot}`);
+        const result = await runAutoInject(options.projectRoot, [options.type], options.dryRun);
+        if (!result.success) {
+            console.error(`Error: ${result.error}`);
+            process.exitCode = 1;
+            return;
+        }
+        const relativeLayout = path.relative(options.projectRoot, result.filePath);
+        console.log(`Found root layout: ${relativeLayout}`);
+        for (const message of result.messages ?? []) {
+            console.log(`[mayson] ${message}`);
+        }
+        if (options.dryRun) {
+            console.log(`[dry-run] Would inject: ${result.injectedComponents.join(', ') || '(none)'}`);
+            if (result.skippedComponents.length > 0) {
+                console.log(`[dry-run] Already present: ${result.skippedComponents.join(', ')}`);
+            }
+            return;
+        }
+        if (result.injectedComponents.length > 0) {
+            console.log(`Injected: ${result.injectedComponents.join(', ')}`);
+        }
+        if (result.skippedComponents.length > 0) {
+            console.log(`Skipped (already present): ${result.skippedComponents.join(', ')}`);
+        }
+        if (result.injectedComponents.length === 0 &&
+            result.skippedComponents.length === 0 &&
+            (result.messages?.length ?? 0) > 0) {
+            console.log('Nothing to inject.');
+        }
+        else if (result.injectedComponents.length === 0 &&
+            result.skippedComponents.length > 0) {
+            console.log('Root layout is up to date.');
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/core/find-root-layout.d.ts

@@ -0,0 +1,2 @@
+export declare function findRootLayout(projectRoot?: string): string | null;
+//# sourceMappingURL=find-root-layout.d.ts.map

package/dist/core/find-root-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-root-layout.d.ts","sourceRoot":"","sources":["../../src/core/find-root-layout.ts"],"names":[],"mappings":"AAgDA,wBAAgB,cAAc,CAAC,WAAW,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CA0BjF"}

package/dist/core/find-root-layout.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const LAYOUT_EXTENSIONS = ['.tsx', '.jsx', '.ts', '.js'];
+function findLayoutFiles(dir, fileList = []) {
+    if (!fs.existsSync(dir))
+        return fileList;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                continue;
+            }
+            findLayoutFiles(fullPath, fileList);
+        }
+        else if (entry.isFile()) {
+            const ext = path.extname(entry.name);
+            const base = path.basename(entry.name, ext);
+            if (base === 'layout' && LAYOUT_EXTENSIONS.includes(ext)) {
+                fileList.push(fullPath);
+            }
+        }
+    }
+    return fileList;
+}
+function scoreLayoutCandidate(filePath, projectRoot) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const relativePath = path.relative(projectRoot, filePath);
+    const depth = relativePath.split(path.sep).length;
+    let score = 100 - depth;
+    if (/<html/i.test(content))
+        score += 50;
+    if (/<body/i.test(content))
+        score += 50;
+    const isDirectAppChild = /^src[/\\]app[/\\]layout\.[jt]sx?$/.test(relativePath) ||
+        /^app[/\\]layout\.[jt]sx?$/.test(relativePath);
+    if (isDirectAppChild)
+        score += 40;
+    return score;
+}
+export function findRootLayout(projectRoot = process.cwd()) {
+    const possibleAppDirs = [
+        path.join(projectRoot, 'src', 'app'),
+        path.join(projectRoot, 'app'),
+    ];
+    const candidateFiles = [];
+    for (const appDir of possibleAppDirs) {
+        if (fs.existsSync(appDir)) {
+            findLayoutFiles(appDir, candidateFiles);
+        }
+    }
+    if (candidateFiles.length === 0) {
+        return null;
+    }
+    const scored = candidateFiles.map((filePath) => ({
+        filePath,
+        score: scoreLayoutCandidate(filePath, projectRoot),
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    return scored[0]?.filePath || null;
+}

package/dist/core/generators.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentGeneratorOptions, ComponentType, GeneratedComponentInfo } from './types.js';
+export type { ComponentGeneratorOptions, ComponentType, GeneratedComponentInfo, } from './types.js';
+export declare function generateComponents(types: ComponentType[] | undefined, options: ComponentGeneratorOptions): GeneratedComponentInfo[];
+//# sourceMappingURL=generators.d.ts.map

package/dist/core/generators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../../src/core/generators.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,yBAAyB,EACzB,aAAa,EACb,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,yBAAyB,EACzB,aAAa,EACb,sBAAsB,GACvB,MAAM,YAAY,CAAC;AAQpB,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EAAE,YAAgB,EACtC,OAAO,EAAE,yBAAyB,GACjC,sBAAsB,EAAE,CAkC1B"}

package/dist/core/generators.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { plugins } from '../plugins/index.js';
+const ALL_TYPES = [
+    'watermark',
+    'ascii',
+    'metadata',
+];
+export function generateComponents(types = ['watermark'], options) {
+    const { outputDir, isTypeScript = true, dryRun = false } = options;
+    const ext = isTypeScript ? '.tsx' : '.jsx';
+    const results = [];
+    if (!dryRun && !fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    const selectedTypes = types.includes('all')
+        ? ALL_TYPES
+        : types.filter((t) => t !== 'all');
+    for (const type of selectedTypes) {
+        const plugin = plugins[type];
+        if (!plugin) {
+            continue;
+        }
+        const code = plugin.generateSource(options.context);
+        const filePath = path.join(outputDir, `${plugin.name}${ext}`);
+        if (!dryRun) {
+            fs.writeFileSync(filePath, code, 'utf-8');
+        }
+        results.push({
+            name: plugin.name,
+            filePath,
+            importStatement: `import { ${plugin.name} } from './${plugin.name}';`,
+            jsxTag: `<${plugin.name} />`,
+        });
+    }
+    return results;
+}

package/dist/core/injector.d.ts

@@ -0,0 +1,4 @@
+import type { InjectorOptions, InjectorResult } from './types.js';
+export type { InjectorOptions, InjectorResult } from './types.js';
+export declare function injectComponentsIntoLayout(options: InjectorOptions): InjectorResult;
+//# sourceMappingURL=injector.d.ts.map

package/dist/core/injector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injector.d.ts","sourceRoot":"","sources":["../../src/core/injector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAElE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAElE,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CAqFnF"}

package/dist/core/injector.js

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function injectComponentsIntoLayout(options) {
+    const { filePath, components, dryRun = false } = options;
+    if (!fs.existsSync(filePath)) {
+        return {
+            success: false,
+            filePath,
+            injectedComponents: [],
+            skippedComponents: [],
+            error: `Layout file not found: ${filePath}`,
+        };
+    }
+    let content = fs.readFileSync(filePath, 'utf-8');
+    const injectedComponents = [];
+    const skippedComponents = [];
+    for (const comp of components) {
+        const importMarker = comp.name;
+        const jsxMarker = `<${comp.name}`;
+        // Skip if already injected
+        if (content.includes(importMarker) || content.includes(jsxMarker)) {
+            skippedComponents.push(comp.name);
+            continue;
+        }
+        // Determine component file import path relative to layout.tsx
+        const layoutDir = path.dirname(filePath);
+        const compDir = path.dirname(comp.filePath);
+        const compBaseName = path.basename(comp.filePath, path.extname(comp.filePath));
+        let relativeImportPath = path.relative(layoutDir, path.join(compDir, compBaseName));
+        if (!relativeImportPath.startsWith('.')) {
+            relativeImportPath = `./${relativeImportPath}`;
+        }
+        // Convert backslashes for Windows path consistency
+        relativeImportPath = relativeImportPath.replace(/\\/g, '/');
+        const importLine = `import { ${comp.name} } from '${relativeImportPath}';\n`;
+        // 1. Insert import statement
+        const importMatches = Array.from(content.matchAll(/import\s+.*?from\s+['"].*?['"];?/g));
+        if (importMatches.length > 0) {
+            const lastMatch = importMatches[importMatches.length - 1];
+            const insertPos = lastMatch.index + lastMatch[0].length;
+            content = content.slice(0, insertPos) + '\n' + importLine + content.slice(insertPos);
+        }
+        else {
+            content = importLine + content;
+        }
+        // 2. Insert JSX tag into return block
+        const jsxSnippet = `\n      {/* @mayson-component-injected: ${comp.name} */}\n      ${comp.jsxTag}`;
+        if (/<\/body>/i.test(content)) {
+            content = content.replace(/<\/body>/i, `${jsxSnippet}\n      </body>`);
+        }
+        else if (/<\/html>/i.test(content)) {
+            content = content.replace(/<\/html>/i, `${jsxSnippet}\n      </html>`);
+        }
+        else {
+            const lastClosingIndex = content.lastIndexOf('</');
+            if (lastClosingIndex !== -1) {
+                content =
+                    content.slice(0, lastClosingIndex) +
+                        jsxSnippet +
+                        '\n      ' +
+                        content.slice(lastClosingIndex);
+            }
+        }
+        injectedComponents.push(comp.name);
+    }
+    if (injectedComponents.length > 0 && !dryRun) {
+        fs.writeFileSync(filePath, content, 'utf-8');
+    }
+    return {
+        success: true,
+        filePath,
+        injectedComponents,
+        skippedComponents,
+        modifiedContent: content,
+    };
+}

package/dist/core/types.d.ts

@@ -0,0 +1,48 @@
+export type ComponentType = 'watermark' | 'ascii' | 'metadata' | 'all';
+export interface GeneratedComponentInfo {
+    name: string;
+    filePath: string;
+    importStatement: string;
+    jsxTag: string;
+}
+/** Context passed into plugin generateSource (e.g. watermark flags from API). */
+export type PluginGenerateContext = {
+    watermark?: {
+        showRemixPill: boolean;
+        enableRemix: boolean;
+        appBaseUrl: string;
+        collectionId: string;
+    };
+};
+export interface ComponentGeneratorOptions {
+    outputDir: string;
+    isTypeScript?: boolean;
+    /** When true, return component info without writing files. */
+    dryRun?: boolean;
+    /** Plugin template context (API / env resolved flags). */
+    context?: PluginGenerateContext;
+}
+export interface InjectorOptions {
+    filePath: string;
+    components: GeneratedComponentInfo[];
+    dryRun?: boolean;
+}
+export interface InjectorResult {
+    success: boolean;
+    filePath: string;
+    injectedComponents: string[];
+    skippedComponents: string[];
+    modifiedContent?: string;
+    error?: string;
+    /** Extra notes (e.g. watermark skipped because show_remix_pill is false). */
+    messages?: string[];
+}
+/** Descriptor for a generate-and-inject plugin. */
+export interface MaysonPlugin {
+    type: Exclude<ComponentType, 'all'>;
+    /** Exported React component name, e.g. MaysonWatermark */
+    name: string;
+    /** Source for the component file written next to the root layout */
+    generateSource: (context?: PluginGenerateContext) => string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,OAAO,GAAG,UAAU,GAAG,KAAK,CAAC;AAEvE,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,iFAAiF;AACjF,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,CAAC,EAAE;QACV,aAAa,EAAE,OAAO,CAAC;QACvB,WAAW,EAAE,OAAO,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,OAAO,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,sBAAsB,EAAE,CAAC;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,mDAAmD;AACnD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IACpC,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,cAAc,EAAE,CAAC,OAAO,CAAC,EAAE,qBAAqB,KAAK,MAAM,CAAC;CAC7D"}