create-velocms-plugin 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VeloCMS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# create-velocms-plugin
+
+Scaffolding CLI for VeloCMS plugin developers. Generates a ready-to-develop plugin template with all necessary boilerplate.
+
+## Usage
+
+```bash
+npx create-velocms-plugin@latest my-plugin
+```
+
+This interactive CLI will ask you for:
+- Plugin name
+- Plugin slug (kebab-case identifier)
+- Plugin type (block, integration, or widget)
+- Plugin category (e.g., seo, commerce, writing, analytics)
+- Author name
+- Plugin description
+
+## Output
+
+The CLI generates a directory with:
+
+```
+my-plugin/
+├── src/
+│   ├── index.ts         # Main plugin hook handler(s) + manifest
+│   └── admin.tsx        # Optional admin UI component
+├── tests/
+│   └── example.test.ts  # Example test case (node:test + @velocms/plugin-sdk/test-helpers)
+├── manifest.json         # Generated plugin manifest (auto-populated)
+├── package.json          # npm config with @velocms/plugin-sdk dependency
+├── tsconfig.json         # TypeScript configuration
+├── tsconfig.build.json   # Build-time tsconfig (excludes tests/)
+├── README.md             # Getting started guide
+├── .gitignore            # Standard ignores
+├── .npmignore            # What NOT to publish alongside dist/
+└── .eslintrc.json        # ESLint config (VeloCMS standards)
+```
+
+## Next steps
+
+After scaffolding:
+
+```bash
+cd my-plugin
+npm install
+npm run build
+npm run dev
+```
+
+For full plugin development guide, see https://velocms.org/developers/sdk.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import { mkdirSync, writeFileSync, readFileSync, copyFileSync, existsSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function prompt(question, defaultValue) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const query = defaultValue ? `${question} (${defaultValue}) ` : `${question} `;
+        rl.question(query, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || "");
+        });
+    });
+}
+function generateManifest(config, _templatePath) {
+    const authorEmail = config.author.includes("@") ? config.author : `${config.author.toLowerCase().replace(/\s+/g, ".")}@example.com`;
+    return JSON.stringify({
+        $schema: "https://velocms.org/schemas/plugin-v2.json",
+        name: `@example/${config.slug}`,
+        displayName: config.name,
+        version: "1.0.0",
+        description: config.description,
+        author: {
+            name: config.author,
+            email: authorEmail,
+        },
+        type: config.type,
+        category: config.category,
+        icon: "./icon.png",
+        engines: {
+            velocms: ">=1.0.0",
+        },
+        capabilities: {
+            content: { read: true },
+        },
+        pricing: {
+            model: "free",
+        },
+        entry: {
+            runtime: "./dist/runtime.js",
+        },
+        permissions_displayed_to_user: ["Read your posts and pages"],
+        license: "MIT",
+    }, null, 2);
+}
+function copyDir(src, dest) {
+    mkdirSync(dest, { recursive: true });
+    try {
+        const files = readdirSync(src, { withFileTypes: true });
+        for (const file of files) {
+            const srcPath = join(src, file.name);
+            const destPath = join(dest, file.name);
+            if (file.isDirectory()) {
+                copyDir(srcPath, destPath);
+            }
+            else {
+                copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Failed to copy directory: ${err}`);
+        process.exit(1);
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const nonInteractive = args.includes("--non-interactive");
+    const slugArg = args.find((a) => a.startsWith("--slug="))?.split("=")[1];
+    let pluginName = args[0] || (nonInteractive ? slugArg : "");
+    if (!pluginName) {
+        console.log("\n🎨 VeloCMS Plugin Scaffolder\n");
+        pluginName = await prompt("Plugin name:", "my-plugin");
+    }
+    if (!pluginName) {
+        console.error("❌ Plugin name is required");
+        process.exit(1);
+    }
+    const pluginSlug = slugArg || (nonInteractive ? pluginName.toLowerCase().replace(/\s+/g, "-") : await prompt("Plugin slug (kebab-case):", pluginName.toLowerCase().replace(/\s+/g, "-")));
+    const pluginType = nonInteractive ? "integration" : await prompt("Plugin type (block|integration|widget):", "integration");
+    const pluginCategory = nonInteractive ? "writing" : await prompt("Plugin category (e.g., seo, commerce, writing, analytics):", "writing");
+    const authorName = nonInteractive ? "Plugin Author" : await prompt("Author name:", "Plugin Author");
+    const description = nonInteractive ? "A VeloCMS plugin" : await prompt("Plugin description:", "A VeloCMS plugin");
+    const config = {
+        name: pluginName,
+        slug: pluginSlug,
+        category: pluginCategory,
+        type: pluginType,
+        author: authorName,
+        description: description,
+    };
+    const outputDir = join(process.cwd(), pluginSlug);
+    if (existsSync(outputDir)) {
+        console.error(`❌ Directory ${outputDir} already exists`);
+        process.exit(1);
+    }
+    mkdirSync(outputDir, { recursive: true });
+    const templateDir = join(__dirname, "template");
+    if (!existsSync(templateDir)) {
+        console.error(`❌ Template directory not found at ${templateDir}`);
+        process.exit(1);
+    }
+    try {
+        const RENAME_MAP = {
+            "gitignore.template": ".gitignore",
+            "npmignore.template": ".npmignore",
+        };
+        function processDir(src, dest) {
+            const files = readdirSync(src, { withFileTypes: true });
+            for (const file of files) {
+                const srcPath = join(src, file.name);
+                const renamedTo = RENAME_MAP[file.name];
+                const destPath = renamedTo
+                    ? join(dest, renamedTo)
+                    : file.name.endsWith(".template")
+                        ? join(dest, file.name.slice(0, -9))
+                        : join(dest, file.name);
+                if (file.isDirectory()) {
+                    mkdirSync(destPath, { recursive: true });
+                    processDir(srcPath, destPath);
+                }
+                else if (file.name !== "manifest.json") {
+                    let content = readFileSync(srcPath, "utf-8");
+                    content = content
+                        .replace(/{{PLUGIN_NAME}}/g, config.name)
+                        .replace(/{{PLUGIN_SLUG}}/g, config.slug)
+                        .replace(/{{PLUGIN_CATEGORY}}/g, config.category)
+                        .replace(/{{PLUGIN_TYPE}}/g, config.type)
+                        .replace(/{{AUTHOR_NAME}}/g, config.author)
+                        .replace(/{{PLUGIN_DESCRIPTION}}/g, config.description);
+                    writeFileSync(destPath, content);
+                }
+            }
+        }
+        processDir(templateDir, outputDir);
+    }
+    catch (err) {
+        console.error(`Failed to copy template: ${err}`);
+        process.exit(1);
+    }
+    const manifestContent = generateManifest(config, templateDir);
+    writeFileSync(join(outputDir, "manifest.json"), manifestContent);
+    console.log(`\n✔ Created plugin scaffold at ./${pluginSlug}`);
+    console.log(`✔ Run \`cd ${pluginSlug} && npm install\``);
+    console.log(`✔ Run \`npm run dev\` to test against a local VeloCMS instance\n`);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/template/.eslintrc.json

@@ -0,0 +1,24 @@
+{
+  "extends": [
+    "eslint:recommended"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 2020,
+    "sourceType": "module"
+  },
+  "env": {
+    "es2020": true,
+    "node": true
+  },
+  "rules": {
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": [
+      "warn",
+      {
+        "argsIgnorePattern": "^_"
+      }
+    ],
+    "no-console": "off"
+  }
+}

package/dist/template/README.md

@@ -0,0 +1,135 @@
+# {{PLUGIN_NAME}}
+
+{{PLUGIN_DESCRIPTION}}
+
+## Getting started
+
+```bash
+npm install
+npm run build
+```
+
+## Development
+
+Watch mode:
+
+```bash
+npm run dev
+```
+
+## Testing
+
+This plugin uses `@velocms/plugin-sdk/test-helpers` so you can write unit tests
+without a running VeloCMS instance:
+
+```typescript
+import { mockVelocms } from "@velocms/plugin-sdk/test-helpers";
+import { afterPostPublish } from "../src/index.js";
+
+const ctx = mockVelocms({
+  tenant: { id: "t1", slug: "my-blog", locale: "en-US" },
+});
+
+await afterPostPublish({ post: { slug: "hello-world" } }, ctx);
+// ctx._fetchCalls, ctx._logs, ctx._kvStore are available for assertions
+```
+
+Run tests:
+
+```bash
+npm run test
+```
+
+## Integration with VeloCMS
+
+This plugin conforms to the [VeloCMS Plugin Manifest v2](https://velocms.org/developers/sdk#manifest).
+The `manifest.json` file declares:
+
+- **Type**: {{PLUGIN_TYPE}}
+- **Category**: {{PLUGIN_CATEGORY}}
+- **Author**: {{AUTHOR_NAME}}
+
+### Manifest field reference
+
+| Field | Required | Description |
+|---|---|---|
+| `name` | Yes | npm-style scoped name e.g. `@myorg/my-plugin` |
+| `displayName` | Yes | Human-readable title shown in marketplace |
+| `version` | Yes | Semantic version e.g. `1.0.0` |
+| `description` | Yes | One-line summary |
+| `author.name` | Yes | Display name of the developer |
+| `author.email` | Yes | Contact email for review communication |
+| `type` | Yes | `block` / `integration` / `widget` |
+| `category` | Yes | `seo` / `commerce` / `analytics` / `writing` / `social` / `media` / `other` |
+| `capabilities.network.allowlist` | Conditional | Required if plugin makes HTTP requests — list of bare domains |
+| `pricing.model` | Yes | `free` or `paid` |
+| `pricing.priceCents` | Conditional | Required when `model === "paid"` — price in USD cents |
+| `permissions_displayed_to_user` | Yes | Plain-English list of what the plugin does — shown in the install consent modal |
+| `engines.velocms` | No | Semver range for VeloCMS engine compatibility e.g. `>=1.0.0` |
+| `entry.runtime` | Yes | Path to the compiled runtime bundle e.g. `./dist/runtime.js` |
+| `entry.admin` | No | Path to compiled admin UI component bundle |
+| `license` | Yes | SPDX identifier e.g. `MIT`, `Apache-2.0` |
+
+See `src/index.ts` for the hook implementation.
+
+## Publishing
+
+1. Build: `npm run build`
+2. Verify: `node dist/index.js` — confirm the plugin loads without error
+3. Log in to the VeloCMS developer portal: `https://velocms.org/developers`
+4. Create a developer account and complete Stripe Connect onboarding (for paid plugins)
+5. Submit for review: `https://velocms.org/plugins/submit`
+   - Upload `dist/` bundle
+   - Paste your `manifest.json`
+   - Wait for the automated review pipeline (Stage 1–4) then human review
+
+### Automated CI for plugin authors
+
+Copy the following workflow to your repo as `.github/workflows/plugin-publish.yml`:
+
+```yaml
+name: VeloCMS Plugin Publish
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  build-and-submit:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm run test
+
+      - name: Build
+        run: npm run build
+
+      - name: Submit to VeloCMS marketplace
+        env:
+          VELOCMS_DEVELOPER_TOKEN: ${{ secrets.VELOCMS_DEVELOPER_TOKEN }}
+        run: |
+          VERSION="${GITHUB_REF#refs/tags/v}"
+          curl -X POST https://velocms.org/api/developer/plugin-submit \
+            -H "Authorization: Bearer $VELOCMS_DEVELOPER_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d "{\"version\":\"$VERSION\",\"bundleUrl\":\"https://github.com/$GITHUB_REPOSITORY/releases/download/$GITHUB_REF_NAME/dist.zip\"}"
+```
+
+> Set `VELOCMS_DEVELOPER_TOKEN` in your repository secrets (GitHub → Settings → Secrets).
+
+## License
+
+MIT

package/dist/template/gitignore.template

@@ -0,0 +1,5 @@
+node_modules/
+dist/
+*.tsbuildinfo
+.DS_Store
+*.log

package/dist/template/npmignore.template

@@ -0,0 +1,9 @@
+src/
+tests/
+tsconfig.json
+tsconfig.build.json
+*.tsbuildinfo
+.eslintrc.json
+.DS_Store
+*.log
+node_modules/

package/dist/template/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@example/{{PLUGIN_SLUG}}",
+  "version": "1.0.0",
+  "description": "{{PLUGIN_DESCRIPTION}}",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsc --watch",
+    "test": "node --import tsx --test tests/*.test.ts"
+  },
+  "keywords": [
+    "velocms",
+    "plugin",
+    "{{PLUGIN_CATEGORY}}"
+  ],
+  "author": "{{AUTHOR_NAME}}",
+  "license": "MIT",
+  "dependencies": {
+    "@velocms/plugin-sdk": "^1.0.0-alpha.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0",
+    "@types/react": "^19.0.0"
+  }
+}

package/dist/template/src/admin.tsx.template

@@ -0,0 +1,18 @@
+/**
+ * Admin UI component for {{PLUGIN_NAME}}
+ *
+ * Optional: only loaded in the admin dashboard if manifest.entry.admin
+ * is uncommented in manifest.json.
+ *
+ * This is a React component — return JSX for settings UI.
+ */
+
+export default function AdminPanel() {
+  return (
+    <div style={{ padding: "1rem" }}>
+      <h2>{{PLUGIN_NAME}} Settings</h2>
+      <p>Configure your plugin here.</p>
+      {/* Add form fields, toggles, etc. */}
+    </div>
+  );
+}

package/dist/template/src/index.ts.template

@@ -0,0 +1,72 @@
+/**
+ * {{PLUGIN_NAME}}
+ *
+ * A minimal VeloCMS plugin scaffold showing how to:
+ * 1. Export a `manifest` object (required)
+ * 2. Implement hook handlers (see manifest.entry.runtime)
+ * 3. Export admin settings UI (optional, see manifest.entry.admin)
+ */
+
+import type {
+  PluginManifest,
+  HookContext,
+  AfterPostPublishPayload,
+} from "@velocms/plugin-sdk";
+
+/**
+ * Plugin manifest — declares metadata, capabilities, and entry points.
+ * This is the canonical shape that the VeloCMS review pipeline validates.
+ */
+export const manifest: PluginManifest = {
+  $schema: "https://velocms.org/schemas/plugin-v2.json",
+  name: "@example/{{PLUGIN_SLUG}}",
+  displayName: "{{PLUGIN_NAME}}",
+  version: "1.0.0",
+  description: "{{PLUGIN_DESCRIPTION}}",
+  author: {
+    name: "{{AUTHOR_NAME}}",
+    email: "author@example.com",
+  },
+  type: "{{PLUGIN_TYPE}}" as any,
+  category: "{{PLUGIN_CATEGORY}}",
+  icon: "./icon.png",
+  engines: {
+    velocms: ">=1.0.0",
+  },
+  capabilities: {
+    content: { read: true },
+  },
+  pricing: {
+    model: "free",
+  },
+  entry: {
+    runtime: "./dist/runtime.js",
+    // admin: "./dist/admin.js", // Uncomment to enable admin UI
+  },
+  permissions_displayed_to_user: [
+    "Read your posts and pages",
+  ],
+  license: "MIT",
+};
+
+/**
+ * Hook handler example.
+ *
+ * Replace this with actual logic for your plugin. VeloCMS matches exported
+ * function names against the SDK's `HookName` union — export a function
+ * named exactly like the hook you want to handle, e.g.:
+ * - `afterPostPublish`: fired when a post is published
+ * - `afterPostCreate` / `afterPostUpdate` / `afterPostDelete`
+ * - `afterMemberSignup` / `afterMemberUpdate`
+ * - `onAppStart`: fired once when the plugin runtime loads (init logic)
+ *
+ * Import the `HookName` union from `@velocms/plugin-sdk` for the full list.
+ */
+export async function afterPostPublish(
+  payload: AfterPostPublishPayload,
+  ctx: HookContext
+): Promise<void> {
+  ctx.log.info("Post published", { slug: payload.post.slug });
+
+  // Example: validate content, send a webhook via ctx.fetch(), etc.
+}

package/dist/template/tests/example.test.ts.template

@@ -0,0 +1,83 @@
+/**
+ * {{PLUGIN_NAME}} — tests
+ *
+ * Uses @velocms/plugin-sdk/test-helpers to write unit tests without
+ * a running VeloCMS instance. Replace with your own test cases.
+ */
+
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { mockVelocms } from "@velocms/plugin-sdk/test-helpers";
+import { manifest, afterPostPublish } from "../src/index.js";
+
+test("manifest is exported with correct name", () => {
+  assert.ok(manifest);
+  assert.equal(manifest.name, "@example/{{PLUGIN_SLUG}}");
+  assert.equal(manifest.displayName, "{{PLUGIN_NAME}}");
+});
+
+test("manifest has required fields", () => {
+  assert.ok(manifest.version);
+  assert.ok(manifest.description);
+  assert.ok(manifest.author?.name);
+  assert.ok(manifest.entry?.runtime);
+  assert.ok(manifest.permissions_displayed_to_user?.length);
+});
+
+test("afterPostPublish executes without throwing", async () => {
+  const ctx = mockVelocms({
+    tenant: { id: "t1", slug: "{{PLUGIN_SLUG}}-test", locale: "en-US" },
+    settings: { blogName: "Test Blog", plan: "pro" },
+  });
+
+  const payload = { post: { slug: "test-post", title: "Test Post" } };
+
+  // Should resolve without error
+  await assert.doesNotReject(() => afterPostPublish(payload as never, ctx));
+});
+
+test("mockVelocms provides working kv store", async () => {
+  const ctx = mockVelocms({ kvStore: { existing_key: "existing_value" } });
+
+  // Pre-seeded key readable
+  assert.equal(await ctx.kv.get("existing_key"), "existing_value");
+
+  // Set + get roundtrip
+  await ctx.kv.set("new_key", "new_value");
+  assert.equal(await ctx.kv.get("new_key"), "new_value");
+
+  // Delete removes key
+  await ctx.kv.delete("new_key");
+  assert.equal(await ctx.kv.get("new_key"), null);
+});
+
+test("mockVelocms records log calls", async () => {
+  const ctx = mockVelocms();
+
+  ctx.log.info("test info message", { extra: "data" });
+  ctx.log.warn("test warn message");
+  ctx.log.error("test error message");
+
+  assert.equal(ctx._logs.length, 3);
+  assert.equal(ctx._logs[0]?.level, "info");
+  assert.equal(ctx._logs[0]?.message, "test info message");
+  assert.deepEqual(ctx._logs[0]?.data, { extra: "data" });
+  assert.equal(ctx._logs[1]?.level, "warn");
+  assert.equal(ctx._logs[2]?.level, "error");
+});
+
+test("mockVelocms records fetch calls", async () => {
+  const ctx = mockVelocms({
+    fetchResponse: { ok: true, status: 200, data: { success: true } },
+  });
+
+  const res = await ctx.fetch("https://api.example.com/webhook", {
+    method: "POST",
+    body: JSON.stringify({ event: "post_published" }),
+  });
+
+  assert.ok(res.ok);
+  assert.equal(ctx._fetchCalls.length, 1);
+  assert.equal(ctx._fetchCalls[0]?.url, "https://api.example.com/webhook");
+  assert.equal(ctx._fetchCalls[0]?.options?.method, "POST");
+});

package/dist/template/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": false,
+    "sourceMap": false,
+    "removeComments": true
+  },
+  "exclude": ["tests/**"]
+}

package/dist/template/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM"],
+    "jsx": "react-jsx",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "create-velocms-plugin",
+  "version": "1.0.0",
+  "description": "Scaffolding tool for VeloCMS plugin development",
+  "type": "module",
+  "bin": {
+    "create-velocms-plugin": "./dist/cli.js"
+  },
+  "main": "./dist/cli.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/copy-template.mjs",
+    "typecheck": "tsc --noEmit",
+    "dev": "node dist/cli.js",
+    "prepublishOnly": "npm run build && npm run typecheck"
+  },
+  "keywords": [
+    "velocms",
+    "cms",
+    "plugin",
+    "cli",
+    "scaffold",
+    "scaffolding",
+    "generator",
+    "create-velocms-plugin"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "VeloCMS",
+    "url": "https://velocms.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/VeloCMS/create-velocms-plugin.git"
+  },
+  "homepage": "https://velocms.org/developers/sdk",
+  "bugs": {
+    "url": "https://github.com/VeloCMS/create-velocms-plugin/issues"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}