@karmaniverous/smoz 0.1.8 → 0.2.0

package/dist/cli/index.cjs

@@ -9,6 +9,8 @@ var node_url = require('node:url');
 var chokidar = require('chokidar');
 var node_child_process = require('node:child_process');
 var os = require('node:os');
+var node_process = require('node:process');
+var promises = require('node:readline/promises');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 /**
@@ -794,8 +796,7 @@ const launchInline = async (root, opts) => {
  * smoz init
  *
  * Scaffolds a new project from packaged templates.
- * - Copies ./templates/project/ into the target root (shared boilerplate)
- * - Copies ./templates/<template>/ into the target root (default: minimal)
+ * - Copies ./templates/<template>/ into the target root (default: default)
  * - Seeds app/generated/register.*.ts (empty modules) if missing * - Idempotent: copy-if-absent; if a file exists, writes <name>.example alongside
  * - Additive merge of template manifest (deps/devDeps/scripts) into package.json
  * - Optional dependency installation via --install[=<pm>]
@@ -808,6 +809,25 @@ const writeIfAbsent = async (outFile, content) => {
     await fs.promises.writeFile(outFile, content, 'utf8');
     return { created: true };
 };
+const askConflict = async (rl, filePath) => {
+    const q = `File exists: ${toPosix(filePath)}\n` +
+        `Choose: [o]verwrite, [e]xample, [s]kip, [O]verwrite all, [E]xample all, [S]kip all: `;
+    // Single key selection for simplicity
+    const ans = (await rl.question(q)).trim();
+    if (/^o$/.test(ans))
+        return 'overwrite';
+    if (/^e$/.test(ans))
+        return 'example';
+    if (/^s$/.test(ans))
+        return 'skip';
+    if (/^O$/.test(ans))
+        return 'all-overwrite';
+    if (/^E$/.test(ans))
+        return 'all-example';
+    if (/^S$/.test(ans))
+        return 'all-skip';
+    return 'example';
+};
 const walk = async (dir, out = []) => {
     const entries = await fs.promises.readdir(dir, { withFileTypes: true });
     for (const ent of entries) {
@@ -928,48 +948,106 @@ const mergeAdditive = (target, source) => {
     target.scripts = scriptsOut;
     return merged;
 };
-const copyDirIdempotent = async (srcDir, dstRoot, created, skipped, examples) => {
+const copyDirWithConflicts = async (srcDir, dstRoot, created, skipped, examples, opts) => {
     const files = await walk(srcDir);
+    let sticky;
     for (const abs of files) {
         const rel = path.relative(srcDir, abs);
         const dest = path.resolve(dstRoot, rel);
         const data = await fs.promises.readFile(abs, 'utf8');
-        if (fs.existsSync(dest)) {
-            const ex = `${dest}.example`;
-            if (!fs.existsSync(ex)) {
-                await writeIfAbsent(ex, data);
-                examples.push(path.posix.normalize(ex));
-            }
-            else {
-                skipped.push(path.posix.normalize(dest));
-            }
-        }
-        else {
+        if (!fs.existsSync(dest)) {
             const { created: c } = await writeIfAbsent(dest, data);
             if (c)
                 created.push(path.posix.normalize(dest));
             else
                 skipped.push(path.posix.normalize(dest));
+            continue;
+        }
+        // Conflict
+        let decision = opts.conflict === 'ask' ? 'example' : opts.conflict;
+        if (opts.conflict === 'ask' && opts.rl && !sticky) {
+            const ans = await askConflict(opts.rl, dest);
+            if (ans === 'all-overwrite') {
+                sticky = 'overwrite';
+            }
+            else if (ans === 'all-example') {
+                sticky = 'example';
+            }
+            else if (ans === 'all-skip') {
+                sticky = 'skip';
+            }
+            else {
+                decision = ans;
+            }
+        }
+        if (sticky)
+            decision = sticky;
+        if (decision === 'overwrite') {
+            await fs.promises.writeFile(dest, data, 'utf8');
+            created.push(path.posix.normalize(dest));
+        }
+        else if (decision === 'example') {
+            const ex = `${dest}.example`;
+            await writeIfAbsent(ex, data);
+            examples.push(path.posix.normalize(ex));
+        }
+        else {
+            skipped.push(path.posix.normalize(dest));
         }
     }
 };
-const runInit = async (root, template = 'minimal', opts) => {
+const runInit = async (root, template = 'default', opts) => {
     const created = [];
     const skipped = [];
     const examples = [];
     const merged = [];
+    const optAll = opts ?? {};
     const templatesBase = resolveTemplatesBase();
-    const srcBase = path.resolve(templatesBase, template);
+    // Resolve template source: named template (default/minimal/full) or filesystem path
+    const templateIsPath = fs.existsSync(template) && (await fs.promises.stat(template)).isDirectory();
+    const srcBase = templateIsPath
+        ? path.resolve(template)
+        : path.resolve(templatesBase, template);
     const projectBase = path.resolve(templatesBase, 'project');
     if (!fs.existsSync(srcBase)) {
-        throw new Error(`Template "${template}" not found under ${toPosix(templatesBase)}.`);
+        throw new Error(`Template "${template}" not found (path or name). Tried: ${toPosix(srcBase)}.`);
     }
     // 1) Copy shared boilerplate (project) first (idempotent)
     if (fs.existsSync(projectBase)) {
-        await copyDirIdempotent(projectBase, root, created, skipped, examples);
+        const rl = optAll.yes
+            ? undefined
+            : promises.createInterface({ input: node_process.stdin, output: node_process.stdout, terminal: true });
+        let policy;
+        const c = optAll.conflict;
+        if (c === 'overwrite' || c === 'example' || c === 'skip' || c === 'ask')
+            policy = c;
+        else
+            policy = optAll.yes ? 'example' : 'ask';
+        const copyOpts = rl
+            ? { conflict: policy, rl }
+            : { conflict: policy };
+        await copyDirWithConflicts(projectBase, root, created, skipped, examples, copyOpts);
+        if (rl)
+            rl.close();
     }
     // 2) Copy selected template
-    await copyDirIdempotent(srcBase, root, created, skipped, examples);
+    {
+        const rl = optAll.yes
+            ? undefined
+            : promises.createInterface({ input: node_process.stdin, output: node_process.stdout, terminal: true });
+        let policy;
+        const c = optAll.conflict;
+        if (c === 'overwrite' || c === 'example' || c === 'skip' || c === 'ask')
+            policy = c;
+        else
+            policy = optAll.yes ? 'example' : 'ask';
+        const copyOpts = rl
+            ? { conflict: policy, rl }
+            : { conflict: policy };
+        await copyDirWithConflicts(srcBase, root, created, skipped, examples, copyOpts);
+        if (rl)
+            rl.close();
+    }
     // 2.5) Convert template 'gitignore' into real '.gitignore'
     // NPM often excludes '.gitignore' from published packages; shipping 'gitignore'
     // and converting here ensures downstream projects get a proper .gitignore.
@@ -1020,55 +1098,59 @@ const runInit = async (root, template = 'minimal', opts) => {
         else
             skipped.push(path.posix.normalize(s.path));
     }
-    // 3) package.json presence (guard or create with --init)
+    // 3) package.json presence (create when missing)
     const pkgPath = path.join(root, 'package.json');
     let pkg = await readJson(pkgPath);
     if (!pkg) {
-        const shouldInit = !!(opts && opts.init);
-        if (shouldInit) {
-            const name = toPosix(root).split('/').pop() ?? 'smoz-app';
-            pkg = {
-                name,
-                private: true,
-                type: 'module',
-                version: '0.0.0',
-                scripts: {},
-            };
-            // Avoid optional chain to satisfy no-unnecessary-condition; normalize to boolean.
-            const dryRunCreate = !!opts.dryRun;
-            if (!dryRunCreate)
-                await writeJson(pkgPath, pkg);
-            created.push(path.posix.normalize(pkgPath));
-        }
-        else {
-            throw new Error('No package.json found. Run "npm init -y" (or re-run with --init) and then "smoz init" again.');
-        }
-    }
-    // 4) Merge manifest (deps/devDeps/scripts) additively
-    const manifestPath = path.resolve(templatesBase, '.manifests', `package.${template}.json`);
-    const manifest = await readJson(manifestPath);
+        const name = toPosix(root).split('/').pop() ?? 'smoz-app';
+        pkg = {
+            name,
+            private: true,
+            type: 'module',
+            version: '0.0.0',
+            scripts: {},
+        };
+        const dryRunCreate = Boolean(optAll.dryRun);
+        if (!dryRunCreate)
+            await writeJson(pkgPath, pkg);
+        created.push(path.posix.normalize(pkgPath));
+    } // 4) Merge manifest (deps/devDeps/scripts) additively
+    // Prefer a real package.json in the template; fallback to legacy manifests if absent.
+    const templatePkgPath = path.resolve(srcBase, 'package.json');
+    const manifest = fs.existsSync(templatePkgPath)
+        ? await readJson(templatePkgPath)
+        : await readJson(path.resolve(templatesBase, '.manifests', `package.${template}.json`));
     if (manifest) {
         const before = JSON.stringify(pkg);
         const added = mergeAdditive(pkg, manifest);
         merged.push(...added);
-        const dryRun = !!(opts && opts.dryRun);
+        const dryRun = Boolean(optAll.dryRun);
         if (!dryRun && before !== JSON.stringify(pkg)) {
             await writeJson(pkgPath, pkg);
         }
     }
     // 5) Optional install
     let installed = 'skipped';
-    const installOpt = opts ? opts.install : false;
+    // Install policy:
+    // -y implies auto install unless --no-install
+    const installOpt = optAll.install ?? false;
+    const impliedAuto = optAll.yes === true && optAll.noInstall !== true && installOpt !== false;
     // Derive package manager to use (explicit string or detected when true),
     // then set installed based on presence of a PM.
     const hasInstallString = typeof installOpt === 'string' && installOpt.trim() !== '';
     const pm = hasInstallString
         ? installOpt
-        : installOpt === true
+        : installOpt === true || impliedAuto
             ? detectPm(root)
             : undefined;
     installed = pm ? runInstall(root, pm) : installed;
-    return { created, skipped, examples, merged, installed };
+    return {
+        created,
+        skipped,
+        examples,
+        merged,
+        installed,
+    };
 };
 
 /**
@@ -1089,6 +1171,22 @@ const readPkg = (root) => {
         return {};
     }
 };
+const readSmozConfig = (root) => {
+    try {
+        const p = path.join(root, 'smoz.config.json');
+        if (!fs.existsSync(p))
+            return {};
+        const raw = fs.readFileSync(p, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object') {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+};
 const detectPackageManager = () => {
     const ua = process.env.npm_config_user_agent ?? '';
     if (ua.includes('pnpm'))
@@ -1134,7 +1232,8 @@ const main = () => {
     program
         .name('smoz')
         .description('SMOZ CLI')
-        .version(pkg.version ?? '0.0.0');
+        // Add -v alias for version in addition to default --version behavior
+        .version(pkg.version ?? '0.0.0', '-v, --version', 'output the version');
     program
         .command('add')
         .argument('<spec>', 'Add function: HTTP <eventType>/<segments...>/<method> or non-HTTP <eventType>/<segments...>')
@@ -1155,16 +1254,46 @@ const main = () => {
     });
     program
         .command('init')
-        .description('Scaffold a new SMOZ app from packaged templates (default: minimal)')
-        .option('--template <name>', 'Template name (minimal|full)', 'minimal')
-        .option('--init', 'Create a minimal package.json if missing')
+        .description('Scaffold a new SMOZ app from packaged templates (default: default)')
+        .option('-t, --template <nameOrPath>', 'Template name or directory path', 'default')
         .option('-i, --install [pm]', 'Install dependencies (optionally specify pm: npm|pnpm|yarn|bun)')
-        .option('--yes', 'Skip prompts (non-interactive)', false)
+        .option('--no-install', 'Skip dependency installation (overrides -y)', false)
+        .option('-y, --yes', 'Skip prompts (non-interactive)', false)
         .option('--dry-run', 'Show planned actions without writing', false)
         .action(async (opts) => {
         try {
-            const tpl = typeof opts.template === 'string' ? opts.template : 'minimal';
-            const { created, skipped, examples, merged, installed } = await runInit(root, tpl, opts);
+            const cfg = readSmozConfig(root).cliDefaults?.init ?? {};
+            // Resolve template: CLI > config > default
+            const tpl = typeof opts.template === 'string'
+                ? opts.template
+                : typeof cfg.template === 'string'
+                    ? cfg.template
+                    : 'default';
+            // Resolve install behavior: CLI > --no-install > config
+            let install = opts.install;
+            if (opts.noInstall === true) {
+                install = false;
+            }
+            else if (install === undefined) {
+                const d = cfg.install;
+                install =
+                    d === 'auto'
+                        ? true
+                        : d === 'none'
+                            ? false
+                            : typeof d === 'string'
+                                ? d
+                                : undefined;
+            }
+            const conflict = typeof opts.conflict === 'string' ? opts.conflict : cfg.onConflict;
+            const { created, skipped, examples, merged, installed } = await runInit(root, tpl, {
+                // Include only when defined to satisfy exactOptionalPropertyTypes
+                ...(install !== undefined ? { install } : {}),
+                ...(typeof conflict === 'string' ? { conflict } : {}),
+                yes: opts.yes === true,
+                noInstall: opts.noInstall === true,
+                dryRun: opts.dryRun === true,
+            });
             console.log([
                 created.length
                     ? `Created:\n - ${created.join('\n - ')}`
@@ -1220,14 +1349,17 @@ const main = () => {
         .option('-v, --verbose', 'Verbose logging', false)
         .action(async (opts) => {
         try {
+            const cfg = readSmozConfig(root).cliDefaults?.dev ?? {};
+            // Resolve local mode default from config if not provided
+            const localResolved = typeof opts.local === 'string'
+                ? opts.local
+                : opts.local === false
+                    ? false
+                    : (cfg.local ?? 'inline');
             await runDev(root, {
                 register: opts.register !== false,
                 openapi: opts.openapi !== false,
-                local: typeof opts.local === 'string'
-                    ? opts.local
-                    : opts.local === false
-                        ? false
-                        : 'inline',
+                local: localResolved,
                 ...(typeof opts.stage === 'string' ? { stage: opts.stage } : {}),
                 port: opts.port ?? 0,
                 verbose: !!opts.verbose,

package/package.json

@@ -182,8 +182,8 @@
     "test": "vitest run",
     "typecheck": "tsx src/cli/index.ts register && tsc -p tsconfig.json --noEmit",
     "templates:typecheck": "tsx scripts/templates-typecheck.ts",
-    "templates:lint": "eslint --fix -c templates/.check/eslint.templates.config.ts \"templates/**/*.{ts,tsx,js,jsx}\" && eslint --fix --no-ignore templates/.check/eslint.templates.config.ts"
+    "templates:lint": "eslint --fix -c templates/default/eslint.config.ts \"templates/default/**/*.{ts,tsx,js,jsx}\" && eslint --fix templates/default/eslint.config.ts"
   },
   "type": "module",
-  "version": "0.1.8"
+  "version": "0.2.0"
 }

package/templates/{minimal → default}/app/config/app.config.ts

@@ -1,50 +1,50 @@
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { App, baseEventTypeMapSchema, toPosixPath } from '@karmaniverous/smoz';
-import { z } from 'zod';
-
-// Derive the app root as the parent directory of app/config/
-export const APP_ROOT_ABS = toPosixPath(
-  fileURLToPath(new URL('..', import.meta.url)),
-);
-
-export const app = App.create({
-  appRootAbs: APP_ROOT_ABS,
-  globalParamsSchema: z.object({
-    PROFILE: z.string(),
-    REGION: z.string(),
-    SERVICE_NAME: z.string(),
-  }),
-  stageParamsSchema: z.object({
-    STAGE: z.string(),
-  }),
-  eventTypeMapSchema: baseEventTypeMapSchema,
-  serverless: {
-    httpContextEventMap: {
-      my: {}, // place a Cognito authorizer here if needed
-      private: { private: true },
-      public: {},
-    },
-    defaultHandlerFileName: 'handler',
-    defaultHandlerFileExport: 'handler',
-  },
-  global: {
-    params: {
-      PROFILE: 'dev',
-      REGION: 'us-east-1',
-      SERVICE_NAME: 'my-smoz-app',
-    },
-    envKeys: ['PROFILE', 'REGION', 'SERVICE_NAME'] as const,
-  },
-  stage: {
-    params: {
-      dev: { STAGE: 'dev' },
-    },
-    envKeys: ['STAGE'] as const,
-  },
-});
-
-export const ENDPOINTS_ROOT_REST = toPosixPath(
-  join(APP_ROOT_ABS, 'functions', 'rest'),
-);
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { App, baseEventTypeMapSchema, toPosixPath } from '@karmaniverous/smoz';
+import { z } from 'zod';
+
+// Derive the app root as the parent directory of app/config/
+export const APP_ROOT_ABS = toPosixPath(
+  fileURLToPath(new URL('..', import.meta.url)),
+);
+
+export const app = App.create({
+  appRootAbs: APP_ROOT_ABS,
+  globalParamsSchema: z.object({
+    PROFILE: z.string(),
+    REGION: z.string(),
+    SERVICE_NAME: z.string(),
+  }),
+  stageParamsSchema: z.object({
+    STAGE: z.string(),
+  }),
+  eventTypeMapSchema: baseEventTypeMapSchema,
+  serverless: {
+    httpContextEventMap: {
+      my: {}, // place a Cognito authorizer here if needed
+      private: { private: true },
+      public: {},
+    },
+    defaultHandlerFileName: 'handler',
+    defaultHandlerFileExport: 'handler',
+  },
+  global: {
+    params: {
+      PROFILE: 'dev',
+      REGION: 'us-east-1',
+      SERVICE_NAME: 'my-smoz-app',
+    },
+    envKeys: ['PROFILE', 'REGION', 'SERVICE_NAME'] as const,
+  },
+  stage: {
+    params: {
+      dev: { STAGE: 'dev' },
+    },
+    envKeys: ['STAGE'] as const,
+  },
+});
+
+export const ENDPOINTS_ROOT_REST = toPosixPath(
+  join(APP_ROOT_ABS, 'functions', 'rest'),
+);

package/templates/{minimal → default}/app/config/openapi.ts

@@ -1,45 +1,45 @@
-import * as path from 'node:path';
-
-import * as fs from 'fs-extra';
-import { packageDirectorySync } from 'pkg-dir';
-import { createDocument } from 'zod-openapi';
-
-import { app } from '@/app/config/app.config';
-/**
- * Template note:
- * - Templates do NOT commit generated register files under app/generated; they
- *   are declared via ambient types (templates/minimal/types/registers.d.ts) so
- *   TypeScript can typecheck without artifacts.
- * - To ensure side effects still run (endpoint registration) and to satisfy
- *   noUncheckedSideEffectImports, import the register module as a namespace and
- *   reference it via `void`.
- * - In real apps, `smoz init` seeds placeholders and `smoz register` rewrites
- *   app/generated/register.*.ts at author time.
- */
-import * as __register_openapi from '@/app/generated/register.openapi';
-void __register_openapi;
-console.log('Generating OpenAPI document...');
-
-const paths = app.buildAllOpenApiPaths();
-export const doc = createDocument({
-  openapi: '3.1.0',
-  servers: [{ description: 'Dev', url: 'http://localhost' }],
-  info: {
-    title: process.env.npm_package_name ?? 'smoz-app',
-    version: process.env.npm_package_version ?? '0.0.0',
-  },
-  paths,
-});
-
-const pkgDir = packageDirectorySync();
-if (!pkgDir) {
-  throw new Error('Could not resolve package root directory');
-}
-const outDir = path.join(pkgDir, 'app', 'generated');
-fs.ensureDirSync(outDir);
-fs.writeFileSync(
-  path.join(outDir, 'openapi.json'),
-  JSON.stringify(doc, null, 2),
-);
-
-console.log('Done!');
+import * as path from 'node:path';
+
+import * as fs from 'fs-extra';
+import { packageDirectorySync } from 'pkg-dir';
+import { createDocument } from 'zod-openapi';
+
+import { app } from '@/app/config/app.config';
+/**
+ * Template note:
+ * - Templates do NOT commit generated register files under app/generated; they
+ *   are declared via ambient types (templates/minimal/types/registers.d.ts) so
+ *   TypeScript can typecheck without artifacts.
+ * - To ensure side effects still run (endpoint registration) and to satisfy
+ *   noUncheckedSideEffectImports, import the register module as a namespace and
+ *   reference it via `void`.
+ * - In real apps, `smoz init` seeds placeholders and `smoz register` rewrites
+ *   app/generated/register.*.ts at author time.
+ */
+import * as __register_openapi from '@/app/generated/register.openapi';
+void __register_openapi;
+console.log('Generating OpenAPI document...');
+
+const paths = app.buildAllOpenApiPaths();
+export const doc = createDocument({
+  openapi: '3.1.0',
+  servers: [{ description: 'Dev', url: 'http://localhost' }],
+  info: {
+    title: process.env.npm_package_name ?? 'smoz-app',
+    version: process.env.npm_package_version ?? '0.0.0',
+  },
+  paths,
+});
+
+const pkgDir = packageDirectorySync();
+if (!pkgDir) {
+  throw new Error('Could not resolve package root directory');
+}
+const outDir = path.join(pkgDir, 'app', 'generated');
+fs.ensureDirSync(outDir);
+fs.writeFileSync(
+  path.join(outDir, 'openapi.json'),
+  JSON.stringify(doc, null, 2),
+);
+
+console.log('Done!');

package/templates/{full → default}/app/functions/rest/hello/get/handler.ts

@@ -1,18 +1,18 @@
-import type { z } from 'zod';
-
-import type { responseSchema } from './lambda';
-import { fn } from './lambda';
-
-type Response = z.infer<typeof responseSchema>;
-
-type FnHandlerApi<T> = {
-  handler: (impl: () => Promise<T> | T) => (...args: unknown[]) => Promise<T>;
-};
-
-const reg = fn as unknown as FnHandlerApi<Response>;
-
-export const handler = reg.handler(async () => {
-  const res: Response = { ok: true };
-  await Promise.resolve(); // satisfy require-await without adding complexity
-  return res;
-});
+import type { z } from 'zod';
+
+import type { responseSchema } from './lambda';
+import { fn } from './lambda';
+
+type Response = z.infer<typeof responseSchema>;
+
+type FnHandlerApi<T> = {
+  handler: (impl: () => Promise<T> | T) => (...args: unknown[]) => Promise<T>;
+};
+
+const reg = fn as unknown as FnHandlerApi<Response>;
+
+export const handler = reg.handler(async () => {
+  const res: Response = { ok: true };
+  await Promise.resolve(); // satisfy require-await without adding complexity
+  return res;
+});

package/templates/{full → default}/app/functions/rest/hello/get/lambda.ts

@@ -1,28 +1,28 @@
-import { join } from 'node:path';
-
-import { toPosixPath } from '@karmaniverous/smoz';
-import { z } from 'zod';
-
-import { app, APP_ROOT_ABS } from '@/app/config/app.config';
-
-export const eventSchema = z.object({}).optional();
-export const responseSchema = z.object({ ok: z.boolean() });
-type FnApi = {
-  handler: <T>(
-    impl: () => Promise<T> | T,
-  ) => (...args: unknown[]) => Promise<T>;
-  openapi: (op: unknown) => void;
-};
-
-export const fn = app.defineFunction({
-  functionName: 'hello_get',
-  eventType: 'rest',
-  httpContexts: ['public'],
-  method: 'get',
-  basePath: 'hello',
-  contentType: 'application/json',
-  eventSchema,
-  responseSchema,
-  callerModuleUrl: import.meta.url,
-  endpointsRootAbs: toPosixPath(join(APP_ROOT_ABS, 'functions', 'rest')),
-}) as unknown as FnApi;
+import { join } from 'node:path';
+
+import { toPosixPath } from '@karmaniverous/smoz';
+import { z } from 'zod';
+
+import { app, APP_ROOT_ABS } from '@/app/config/app.config';
+
+export const eventSchema = z.object({}).optional();
+export const responseSchema = z.object({ ok: z.boolean() });
+type FnApi = {
+  handler: <T>(
+    impl: () => Promise<T> | T,
+  ) => (...args: unknown[]) => Promise<T>;
+  openapi: (op: unknown) => void;
+};
+
+export const fn = app.defineFunction({
+  functionName: 'hello_get',
+  eventType: 'rest',
+  httpContexts: ['public'],
+  method: 'get',
+  basePath: 'hello',
+  contentType: 'application/json',
+  eventSchema,
+  responseSchema,
+  callerModuleUrl: import.meta.url,
+  endpointsRootAbs: toPosixPath(join(APP_ROOT_ABS, 'functions', 'rest')),
+}) as unknown as FnApi;