create-syncular-app 0.1.2 → 0.2.0

package/dist/scaffold.js

@@ -0,0 +1,106 @@
+/**
+ * The scaffolder's heart: copy a template tree into a target directory, with
+ * dumb, greppable placeholder substitution and a single dependency-range
+ * decision. Kept pure of process/argv concerns so tests drive it directly.
+ */
+import { cpSync, existsSync, readdirSync, readFileSync, renameSync, writeFileSync, } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PACKAGE_SCOPE, PLACEHOLDER, PUBLISHED_DEPENDENCY_RANGE, } from './constants.js';
+/** The two templates this rung ships. */
+export const TEMPLATES = ['minimal', 'web'];
+export function isTemplateName(value) {
+    return TEMPLATES.includes(value);
+}
+/** Absolute path to `template/` inside this package (works for src or dist). */
+export function templatesRoot() {
+    return fileURLToPath(new URL('../template', import.meta.url));
+}
+/** Derive a safe npm package name from the target directory basename. */
+export function packageNameFromDirectory(targetDir) {
+    const name = basename(resolve(targetDir))
+        .toLowerCase()
+        .replace(/[^a-z0-9-_.~]+/g, '-')
+        .replace(/^[-._]+|[-._]+$/g, '');
+    return name.length > 0 ? name : `${PACKAGE_SCOPE.slice(1)}-app`;
+}
+function isWorkspacePackage(dependencyName) {
+    return dependencyName.startsWith(`${PACKAGE_SCOPE}/`);
+}
+/**
+ * Rewrite a template's package.json: set `name`, and resolve the dependency
+ * range for every `@<scope>/*` workspace dependency.
+ *
+ * The local-vs-published question, decided honestly (also documented in the
+ * package README):
+ * - `local: true` keeps `workspace:*` verbatim — the only ranges that resolve
+ *   when the scaffolded app sits inside this repo's workspace (the in-tree
+ *   smoke test path, and `--local` for anyone hacking on the tree).
+ * - `local: false` rewrites to {@link PUBLISHED_DEPENDENCY_RANGE}. Today that
+ *   is *also* `workspace:*` because the v2 packages are unpublished and
+ *   version-less (TODO 6.3); the CLI warns. It is one constant to flip the day
+ *   they publish.
+ */
+export function rewriteTemplatePackageJson(source, options) {
+    const pkg = JSON.parse(source);
+    pkg.name = options.packageName;
+    const range = options.local ? 'workspace:*' : PUBLISHED_DEPENDENCY_RANGE;
+    for (const section of [pkg.dependencies, pkg.devDependencies]) {
+        if (section === undefined)
+            continue;
+        for (const [name, current] of Object.entries(section)) {
+            if (isWorkspacePackage(name) && current.startsWith('workspace:')) {
+                section[name] = range;
+            }
+        }
+    }
+    return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+/** Replace `__PROJECT_NAME__` everywhere in a text file body. */
+function substitutePlaceholders(body, projectName) {
+    return body.replaceAll(PLACEHOLDER.projectName, projectName);
+}
+/**
+ * Files whose bodies get `__PROJECT_NAME__` substitution. Everything else is
+ * copied byte-for-byte. Deliberately a short allow-list (missing paths are
+ * skipped per-template) — substitution stays dumb and auditable rather than
+ * scanning every file. Paths are relative + POSIX-joined below.
+ */
+const SUBSTITUTE_FILES = ['README.md', 'src/frontend/index.html'];
+function directoryIsEmpty(path) {
+    return readdirSync(path).length === 0;
+}
+/**
+ * Copy `template/<template>` into `targetDir` and finalize it: restore the
+ * `.gitignore` name (npm strips real dotfiles from tarballs, so templates ship
+ * `gitignore`), rewrite package.json, and substitute placeholders.
+ */
+export function scaffoldApp(options) {
+    const targetDir = resolve(options.targetDir);
+    const templateDir = join(templatesRoot(), options.template);
+    const local = options.local ?? false;
+    if (!existsSync(templateDir)) {
+        throw new Error(`unknown template directory: ${templateDir}`);
+    }
+    if (existsSync(targetDir) && !directoryIsEmpty(targetDir)) {
+        throw new Error(`target directory is not empty: ${targetDir}`);
+    }
+    cpSync(templateDir, targetDir, { recursive: true });
+    const gitignorePlaceholder = join(targetDir, 'gitignore');
+    if (existsSync(gitignorePlaceholder)) {
+        renameSync(gitignorePlaceholder, join(targetDir, '.gitignore'));
+    }
+    const packageName = packageNameFromDirectory(targetDir);
+    const packageJsonPath = join(targetDir, 'package.json');
+    writeFileSync(packageJsonPath, rewriteTemplatePackageJson(readFileSync(packageJsonPath, 'utf8'), {
+        packageName,
+        local,
+    }));
+    for (const relPath of SUBSTITUTE_FILES) {
+        const path = join(targetDir, relPath);
+        if (existsSync(path)) {
+            writeFileSync(path, substitutePlaceholders(readFileSync(path, 'utf8'), packageName));
+        }
+    }
+    return { targetDir, packageName, template: options.template, local };
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "create-syncular-app",
-  "version": "0.1.2",
-  "description": "Scaffold a local-first Syncular app (`bunx create-syncular-app my-app`)",
+  "version": "0.2.0",
+  "description": "Scaffold a new Syncular app: `create-syncular-app`",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
   "homepage": "https://syncular.dev",
   "repository": {
     "type": "git",
     "url": "https://github.com/syncular/syncular.git",
-    "directory": "packages/create-syncular-app"
+    "directory": "packages/create-app"
   },
   "bugs": {
     "url": "https://github.com/syncular/syncular/issues"
@@ -18,30 +18,37 @@
     "offline-first",
     "realtime",
     "database",
-    "typescript",
-    "create",
-    "scaffold"
+    "typescript"
   ],
+  "type": "module",
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
-  "type": "module",
   "bin": {
     "create-syncular-app": "./dist/cli.js"
   },
-  "scripts": {
-    "tsgo": "tsgo --noEmit",
-    "build": "rm -rf dist && bun run build:cli",
-    "build:cli": "bun build ./src/cli.ts --target=node --format=esm --outfile=./dist/cli.js",
-    "smoke": "bun scripts/smoke.ts",
-    "release": "bun run build:cli && syncular-publish"
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "browser": "./src/index.ts",
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
   },
   "files": [
     "dist",
-    "template"
+    "src",
+    "template",
+    "README.md",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts"
   ],
   "devDependencies": {
-    "@syncular/config": "0.0.0"
+    "@syncular/typegen": "0.2.0"
   }
 }

package/src/cli.ts

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/**
+ * `create-syncular-app [project-name] [--template <minimal|web>] [--local]`
+ *
+ * Runnable as `bun create syncular-app my-app` or `bunx create-syncular-app
+ * my-app`. Prompts for anything a flag did not supply. Scaffolds one of the
+ * two templates (see `./scaffold`).
+ */
+import { relative } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { CLI_BIN, CREATE_BIN, PRODUCT_NAME } from './constants';
+import {
+  isTemplateName,
+  scaffoldApp,
+  TEMPLATES,
+  type TemplateName,
+} from './scaffold';
+
+interface ParsedArgs {
+  readonly help: boolean;
+  readonly local: boolean;
+  readonly projectName?: string;
+  readonly template?: TemplateName;
+}
+
+function usage(): string {
+  return `usage: ${CREATE_BIN} [project-name] [options]
+
+Scaffolds a ${PRODUCT_NAME} v2 starter app.
+
+templates:
+  minimal   server + a terminal two-client convergence demo (no browser)
+  web       Hono server + WebSocket + a single-pane browser todo app
+            (worker core on OPFS)
+
+options:
+  --template <name>   one of: ${TEMPLATES.join(', ')} (prompts if omitted)
+  --local             keep workspace:* deps (scaffolding inside this repo)
+  -h, --help          show this help
+
+examples:
+  bun create syncular-app my-app
+  bunx ${CREATE_BIN} my-app --template web
+`;
+}
+
+export function parseArgs(argv: readonly string[]): ParsedArgs {
+  let help = false;
+  let local = false;
+  let projectName: string | undefined;
+  let template: TemplateName | undefined;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '-h' || arg === '--help') {
+      help = true;
+    } else if (arg === '--local') {
+      local = true;
+    } else if (arg === '--template') {
+      const value = argv[i + 1];
+      if (value === undefined) throw new Error('--template requires a value');
+      if (!isTemplateName(value)) {
+        throw new Error(
+          `unknown template ${JSON.stringify(value)} (expected: ${TEMPLATES.join(', ')})`,
+        );
+      }
+      template = value;
+      i += 1;
+    } else if (arg?.startsWith('-')) {
+      throw new Error(`unknown option ${JSON.stringify(arg)}\n\n${usage()}`);
+    } else if (projectName === undefined) {
+      projectName = arg;
+    } else {
+      throw new Error(`unexpected extra argument ${JSON.stringify(arg)}`);
+    }
+  }
+  return {
+    help,
+    local,
+    ...(projectName !== undefined ? { projectName } : {}),
+    ...(template !== undefined ? { template } : {}),
+  };
+}
+
+async function prompt(question: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+async function resolveTemplate(
+  supplied: TemplateName | undefined,
+): Promise<TemplateName> {
+  if (supplied !== undefined) return supplied;
+  const answer = await prompt(
+    `Template? (${TEMPLATES.join(' / ')}) [minimal]: `,
+  );
+  if (answer === '') return 'minimal';
+  if (!isTemplateName(answer)) {
+    throw new Error(
+      `unknown template ${JSON.stringify(answer)} (expected: ${TEMPLATES.join(', ')})`,
+    );
+  }
+  return answer;
+}
+
+function nextSteps(dir: string, template: TemplateName): string {
+  const cd = `  cd ${dir}\n  bun install`;
+  const run =
+    template === 'web'
+      ? '  bun run dev          # http://localhost:8787'
+      : '  bun run server       # terminal 1\n  bun run clients      # terminal 2 — prints "✓ converged"';
+  return `\nDone. Next steps:\n\n${cd}\n  bun run generate     # migrations → src/syncular.generated.ts\n${run}\n\nSee README.md for the layout and what to edit first.\n`;
+}
+
+export async function runCli(argv = process.argv.slice(2)): Promise<number> {
+  let args: ParsedArgs;
+  try {
+    args = parseArgs(argv);
+  } catch (error) {
+    console.error(`[${CREATE_BIN}] ${describe(error)}`);
+    return 1;
+  }
+  if (args.help) {
+    console.log(usage());
+    return 0;
+  }
+
+  try {
+    let projectName = args.projectName;
+    if (projectName === undefined || projectName === '') {
+      projectName = await prompt('Project directory (e.g. my-app): ');
+    }
+    if (projectName === '') {
+      console.error(`[${CREATE_BIN}] a project directory is required`);
+      return 1;
+    }
+    const template = await resolveTemplate(args.template);
+
+    const result = scaffoldApp({
+      template,
+      targetDir: projectName,
+      local: args.local,
+    });
+
+    const displayDir = relative(process.cwd(), result.targetDir) || '.';
+    console.log(
+      `[${CREATE_BIN}] scaffolded ${result.packageName} (template: ${template}) into ${displayDir}`,
+    );
+    if (!result.local) {
+      console.warn(
+        `[${CREATE_BIN}] note: the ${PRODUCT_NAME} v2 packages are not published yet, so\n` +
+          `  the app's dependencies are still workspace:* ranges. Run inside this repo\n` +
+          `  (or pass --local) until publishing lands (TODO 6.3). Use \`${CLI_BIN} generate\`\n` +
+          '  to (re)generate the typed schema.',
+      );
+    }
+    console.log(nextSteps(displayDir, template));
+    return 0;
+  } catch (error) {
+    console.error(`[${CREATE_BIN}] ${describe(error)}`);
+    return 1;
+  }
+}
+
+function describe(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+if (import.meta.main) {
+  process.exitCode = await runCli();
+}

package/src/constants.ts

@@ -0,0 +1,53 @@
+/**
+ * The ONE place naming lives (TODO 6.3 is a product decision — final package
+ * identity is not settled). Every user-visible name the scaffolder emits comes
+ * from here so a rename is mechanical: change these constants, regenerate the
+ * templates' generated files, done. No name is hardcoded elsewhere in this
+ * package — grep for the literals below and you should only find them here.
+ */
+
+/** The scoped npm namespace for the v2 packages, e.g. `@syncular`. */
+export const PACKAGE_SCOPE = '@syncular';
+
+/** The typegen CLI binary name (`syncular generate`, `syncular init`). */
+export const CLI_BIN = 'syncular';
+
+/** This package's own bin (`bun create syncular …` / `bunx create-syncular-app …`). */
+export const CREATE_BIN = 'create-syncular-app';
+
+/** Human-facing product name in prose. */
+export const PRODUCT_NAME = 'syncular';
+
+/**
+ * The scoped workspace packages a template may depend on. The scaffolder only
+ * rewrites ranges for packages under {@link PACKAGE_SCOPE}, so this list is
+ * documentation, not a gate — but it keeps the "what does a template pull in"
+ * question answerable from one spot.
+ */
+export const WORKSPACE_PACKAGES = [
+  `${PACKAGE_SCOPE}/core`,
+  `${PACKAGE_SCOPE}/server`,
+  `${PACKAGE_SCOPE}/server-hono`,
+  `${PACKAGE_SCOPE}/client`,
+  `${PACKAGE_SCOPE}/typegen`,
+] as const;
+
+/**
+ * The dependency range written into a scaffolded app's package.json when NOT
+ * scaffolding for in-tree testing (see {@link scaffoldApp}'s `local` flag).
+ *
+ * The v2 packages are unpublished and version-less today (all `private`, no
+ * `version` field — final identity + the release train is TODO 6.3). Until
+ * they publish there is no honest semver range to point at, so this is a
+ * `workspace:*`-shaped LOCAL default too, and the CLI warns loudly that a
+ * published install is not yet possible. When the packages ship, replace this
+ * with `^<version>` (or teach the CLI to read the published version) — one
+ * edit, here.
+ */
+export const PUBLISHED_DEPENDENCY_RANGE = 'workspace:*';
+
+/** Placeholder tokens substituted verbatim during scaffold (dumb + greppable). */
+export const PLACEHOLDER = {
+  /** Replaced by the chosen project name in package.json/README. */
+  projectName: '__PROJECT_NAME__',
+} as const;

package/src/index.ts

@@ -0,0 +1,3 @@
+/** Programmatic surface (the CLI is the primary entry; tests use these). */
+export * from './constants';
+export * from './scaffold';

package/src/scaffold.ts

@@ -0,0 +1,161 @@
+/**
+ * The scaffolder's heart: copy a template tree into a target directory, with
+ * dumb, greppable placeholder substitution and a single dependency-range
+ * decision. Kept pure of process/argv concerns so tests drive it directly.
+ */
+import {
+  cpSync,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  PACKAGE_SCOPE,
+  PLACEHOLDER,
+  PUBLISHED_DEPENDENCY_RANGE,
+} from './constants';
+
+/** The two templates this rung ships. */
+export const TEMPLATES = ['minimal', 'web'] as const;
+export type TemplateName = (typeof TEMPLATES)[number];
+
+export function isTemplateName(value: string): value is TemplateName {
+  return (TEMPLATES as readonly string[]).includes(value);
+}
+
+/** Absolute path to `template/` inside this package (works for src or dist). */
+export function templatesRoot(): string {
+  return fileURLToPath(new URL('../template', import.meta.url));
+}
+
+/** Derive a safe npm package name from the target directory basename. */
+export function packageNameFromDirectory(targetDir: string): string {
+  const name = basename(resolve(targetDir))
+    .toLowerCase()
+    .replace(/[^a-z0-9-_.~]+/g, '-')
+    .replace(/^[-._]+|[-._]+$/g, '');
+  return name.length > 0 ? name : `${PACKAGE_SCOPE.slice(1)}-app`;
+}
+
+function isWorkspacePackage(dependencyName: string): boolean {
+  return dependencyName.startsWith(`${PACKAGE_SCOPE}/`);
+}
+
+/**
+ * Rewrite a template's package.json: set `name`, and resolve the dependency
+ * range for every `@<scope>/*` workspace dependency.
+ *
+ * The local-vs-published question, decided honestly (also documented in the
+ * package README):
+ * - `local: true` keeps `workspace:*` verbatim — the only ranges that resolve
+ *   when the scaffolded app sits inside this repo's workspace (the in-tree
+ *   smoke test path, and `--local` for anyone hacking on the tree).
+ * - `local: false` rewrites to {@link PUBLISHED_DEPENDENCY_RANGE}. Today that
+ *   is *also* `workspace:*` because the v2 packages are unpublished and
+ *   version-less (TODO 6.3); the CLI warns. It is one constant to flip the day
+ *   they publish.
+ */
+export function rewriteTemplatePackageJson(
+  source: string,
+  options: { packageName: string; local: boolean },
+): string {
+  const pkg = JSON.parse(source) as {
+    name?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+  pkg.name = options.packageName;
+  const range = options.local ? 'workspace:*' : PUBLISHED_DEPENDENCY_RANGE;
+  for (const section of [pkg.dependencies, pkg.devDependencies]) {
+    if (section === undefined) continue;
+    for (const [name, current] of Object.entries(section)) {
+      if (isWorkspacePackage(name) && current.startsWith('workspace:')) {
+        section[name] = range;
+      }
+    }
+  }
+  return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+
+/** Replace `__PROJECT_NAME__` everywhere in a text file body. */
+function substitutePlaceholders(body: string, projectName: string): string {
+  return body.replaceAll(PLACEHOLDER.projectName, projectName);
+}
+
+export interface ScaffoldOptions {
+  readonly template: TemplateName;
+  readonly targetDir: string;
+  /** Keep `workspace:*` ranges (in-tree testing / repo hacking). */
+  readonly local?: boolean;
+}
+
+export interface ScaffoldResult {
+  readonly targetDir: string;
+  readonly packageName: string;
+  readonly template: TemplateName;
+  readonly local: boolean;
+}
+
+/**
+ * Files whose bodies get `__PROJECT_NAME__` substitution. Everything else is
+ * copied byte-for-byte. Deliberately a short allow-list (missing paths are
+ * skipped per-template) — substitution stays dumb and auditable rather than
+ * scanning every file. Paths are relative + POSIX-joined below.
+ */
+const SUBSTITUTE_FILES = ['README.md', 'src/frontend/index.html'] as const;
+
+function directoryIsEmpty(path: string): boolean {
+  return readdirSync(path).length === 0;
+}
+
+/**
+ * Copy `template/<template>` into `targetDir` and finalize it: restore the
+ * `.gitignore` name (npm strips real dotfiles from tarballs, so templates ship
+ * `gitignore`), rewrite package.json, and substitute placeholders.
+ */
+export function scaffoldApp(options: ScaffoldOptions): ScaffoldResult {
+  const targetDir = resolve(options.targetDir);
+  const templateDir = join(templatesRoot(), options.template);
+  const local = options.local ?? false;
+
+  if (!existsSync(templateDir)) {
+    throw new Error(`unknown template directory: ${templateDir}`);
+  }
+  if (existsSync(targetDir) && !directoryIsEmpty(targetDir)) {
+    throw new Error(`target directory is not empty: ${targetDir}`);
+  }
+
+  cpSync(templateDir, targetDir, { recursive: true });
+
+  const gitignorePlaceholder = join(targetDir, 'gitignore');
+  if (existsSync(gitignorePlaceholder)) {
+    renameSync(gitignorePlaceholder, join(targetDir, '.gitignore'));
+  }
+
+  const packageName = packageNameFromDirectory(targetDir);
+
+  const packageJsonPath = join(targetDir, 'package.json');
+  writeFileSync(
+    packageJsonPath,
+    rewriteTemplatePackageJson(readFileSync(packageJsonPath, 'utf8'), {
+      packageName,
+      local,
+    }),
+  );
+
+  for (const relPath of SUBSTITUTE_FILES) {
+    const path = join(targetDir, relPath);
+    if (existsSync(path)) {
+      writeFileSync(
+        path,
+        substitutePlaceholders(readFileSync(path, 'utf8'), packageName),
+      );
+    }
+  }
+
+  return { targetDir, packageName, template: options.template, local };
+}

package/template/minimal/README.md

@@ -0,0 +1,45 @@
+# __PROJECT_NAME__
+
+A minimal [syncular](https://github.com/bkniffler/syncular) v2 app: a schema, a
+~30-line server, and two client cores that converge — all in a terminal, no
+browser. This is the shape you grow a real backend from.
+
+## Run it
+
+```sh
+bun install
+bun run generate          # syncular.json + migrations → src/syncular.generated.ts
+bun run server            # terminal 1 — http://localhost:8787
+bun run clients           # terminal 2 — prints "✓ converged"
+```
+
+`bun test` runs the same convergence path as a smoke test.
+
+## Layout
+
+| File | What it is |
+|---|---|
+| `syncular.json` + `migrations/` | The schema manifest and SQL — typegen's input |
+| `src/syncular.generated.ts` | Generated by `syncular generate` (committed; regenerate on schema change) |
+| `src/server.ts` | The whole sync backend in one Bun process |
+| `src/make-client.ts` | Constructs one `SyncClient` on bun:sqlite + fetch |
+| `src/clients.ts` | Two clients, one server, terminal-visible convergence |
+| `src/smoke.test.ts` | The end-to-end smoke test (`bun test`) |
+
+## What to edit first
+
+1. **`src/server.ts` → `resolveScopes`** — the whole authorization story. It
+   runs in your backend next to your auth. The starter returns `['*']` (see
+   everything); a real one returns the scope values the authenticated actor may
+   see.
+2. **`src/server.ts` → `authenticate`** — plug in your real session/token
+   check; return `{ actorId, partition }` or `null` for a 401.
+3. **`migrations/` + `syncular.json`** — add tables and scopes, then
+   `bun run generate` to refresh the typed schema.
+
+## Next
+
+- Want a browser app? Scaffold the `web` template instead
+  (`bun create syncular-app my-app --template web`).
+- The [docs](https://github.com/bkniffler/syncular) explain scopes, conflicts,
+  bootstrap, realtime, and blobs.

package/template/minimal/gitignore

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

package/template/minimal/migrations/0001_initial/up.sql

@@ -0,0 +1,9 @@
+-- Your schema, one table to start. typegen reads this to derive the schema
+-- SHAPE (column types, primary key); the server manages its own sync_* tables
+-- and never runs this migration.
+CREATE TABLE notes (
+  id TEXT PRIMARY KEY,
+  list_id TEXT NOT NULL,
+  body TEXT NOT NULL,
+  updated_at_ms INTEGER NOT NULL
+);

package/template/minimal/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "__PROJECT_NAME__",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "generate": "syncular generate --manifest-dir .",
+    "server": "bun run src/server.ts",
+    "clients": "bun run src/clients.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@syncular/core": "workspace:*",
+    "@syncular/server": "workspace:*",
+    "@syncular/server-hono": "workspace:*",
+    "@syncular/client": "workspace:*"
+  },
+  "devDependencies": {
+    "@syncular/typegen": "workspace:*",
+    "@types/bun": "latest",
+    "typescript": "^5.9.0"
+  }
+}