@voxgig/build 4.1.0 → 4.3.0

package/env/env_gen.ts

@@ -0,0 +1,179 @@
+/* Copyright © 2026 Voxgig Ltd, MIT License. */
+
+// EnvGen: per-environment deployment artifact generation. The project
+// model declares its target environments under `main: env:`:
+//
+//   main: env: local: { active: true }
+//   main: env: aws: { active: true, region: 'eu-west-1', stage: 'dev' }
+//
+// For each active environment this generates gen/env/<name>/ from the
+// fragment set tm/env/<kind>/ (kind defaults to the env name, so a
+// project can declare e.g. `aws2: { kind: 'aws', region: ... }`).
+// Fragments are project-shadowable via spec.tm (the project's tm/env
+// folder), like the lambda templates.
+
+import Fs from 'fs'
+import Path from 'path'
+
+import { camelify } from '@voxgig/util'
+
+import { CoreConfShape } from '../shape/conf'
+
+import { generate, loadFragment, renderFragment } from './lambda/generate'
+import { web_gen } from './web/web_gen'
+
+
+// The supported environment kinds and the files each generates.
+// `out` may contain $$slots$$ (rendered with the same slot values).
+const ENV_FILES: Record<string, { frag: string, out: string }[]> = {
+  local: [
+    { frag: 'local/run.sh.frag', out: 'run.sh' },
+    { frag: 'local/README.md.frag', out: 'README.md' },
+  ],
+  basic: [
+    { frag: 'basic/backend.service.frag', out: '$$name$$-backend.service' },
+    { frag: 'basic/deploy.sh.frag', out: 'deploy.sh' },
+    { frag: 'basic/README.md.frag', out: 'README.md' },
+  ],
+  docker: [
+    { frag: 'docker/Dockerfile.frag', out: 'Dockerfile' },
+    { frag: 'docker/compose.yml.frag', out: 'compose.yml' },
+    { frag: 'docker/README.md.frag', out: 'README.md' },
+  ],
+  vm: [
+    { frag: 'vm/cloud-init.yaml.frag', out: 'cloud-init.yaml' },
+    { frag: 'vm/README.md.frag', out: 'README.md' },
+  ],
+  aws: [
+    { frag: 'aws/serverless.yml.frag', out: 'serverless.yml' },
+    { frag: 'aws/README.md.frag', out: 'README.md' },
+  ],
+  azure: [
+    { frag: 'azure/host.json.frag', out: 'host.json' },
+    { frag: 'azure/README.md.frag', out: 'README.md' },
+  ],
+  cloudflare: [
+    { frag: 'cloudflare/wrangler.toml.frag', out: 'wrangler.toml' },
+    { frag: 'cloudflare/README.md.frag', out: 'README.md' },
+  ],
+}
+
+// The runtime entry point + Seneca config setup each environment needs
+// under src/env/. These are generated ONCE (only when missing): after
+// creation the project owns them, like the scaffold's local entry. All
+// entries route Seneca configuration through src/env/shared/basic.ts.
+// `dir` is relative to the project src/env folder.
+const ENV_SRC: Record<string, { frag: string, dir: string, out: string }[]> = {
+  local: [], // scaffold provides src/env/local/local.ts
+  basic: [
+    { frag: 'server.entry.ts.frag', dir: 'basic', out: 'basic.ts' },
+  ],
+  docker: [
+    { frag: 'server.entry.ts.frag', dir: 'docker', out: 'docker.ts' },
+  ],
+  vm: [
+    { frag: 'server.entry.ts.frag', dir: 'vm', out: 'vm.ts' },
+  ],
+  aws: [
+    // The Lambda bootstrap the generated handlers import.
+    { frag: 'aws/lambda.entry.ts.frag', dir: 'lambda', out: 'lambda.ts' },
+  ],
+  azure: [
+    { frag: 'azure/entry.ts.frag', dir: 'azure', out: 'azure.ts' },
+  ],
+  cloudflare: [
+    { frag: 'cloudflare/worker.ts.frag', dir: 'cloudflare', out: 'worker.ts' },
+  ],
+}
+
+const KINDS = Object.keys(ENV_FILES)
+
+
+const env_gen = async (model: any, spec: {
+  folder: string     // gen/env output root; each env writes <folder>/<name>/
+  tm?: string        // project tm/env folder (fragment shadowing)
+  src?: string       // project src/env folder: runtime entries generated
+                     // here ONCE (existing files are never overwritten)
+  root?: string      // project root (holds backend/ and web/) - required
+                     // for the 'web' kind (full frontend generation)
+}) => {
+
+  const core = CoreConfShape(model.main.conf.core)
+  const envs = model.main.env || {}
+
+  for (const entry of Object.entries(envs)) {
+    const name = entry[0]
+    const def: any = entry[1] || {}
+
+    if (false === def.active) {
+      continue
+    }
+
+    const kind = def.kind || name
+
+    // The 'web' kind is the frontend SPA (+ backend web runner + auth),
+    // not a flat deployment-artifact set - delegate to EnvWeb.
+    if ('web' === kind) {
+      if (null == spec.root) {
+        throw new Error('@voxgig/build: env kind "web" needs spec.root ' +
+          '(the project root); pass it from the build action')
+      }
+      await web_gen(model, { root: spec.root, tm: spec.tm, env: def })
+      continue
+    }
+    const filedefs = ENV_FILES[kind]
+    if (null == filedefs) {
+      throw new Error('@voxgig/build: unknown environment kind: ' + kind +
+        ' (env ' + name + '; known kinds: ' + KINDS.join(', ') + ')')
+    }
+
+    // Slot values: project identity, ports, and per-env config with
+    // sensible defaults. Additional scalar config keys on the env
+    // definition become slots too.
+    const slots: Record<string, any> = {
+      name: core.name,
+      Name: camelify(core.name),
+      env: name,
+      port: model.main.conf.port?.backend || 8080,
+      node: def.node || '22',
+      region: def.region || 'us-east-1',
+      stage: def.stage || 'dev',
+    }
+    for (const key of Object.keys(def)) {
+      if ('object' !== typeof def[key] && null == slots[key]) {
+        slots[key] = def[key]
+      }
+    }
+
+    // Slot for the env name inside entry fragments.
+    slots.env = name
+
+    const files = filedefs.map((fd) => ({
+      name: renderFragment(fd.out, slots),
+      content: renderFragment(loadFragment(fd.frag, spec, 'env'), slots),
+    }))
+
+    await generate(spec.folder + '/' + name, files)
+
+    // Runtime entries: create-once into src/env (user-owned afterwards).
+    if (null != spec.src) {
+      for (const sd of (ENV_SRC[kind] || [])) {
+        const dest = Path.join(spec.src, sd.dir, renderFragment(sd.out, slots))
+        if (!Fs.existsSync(dest)) {
+          const content =
+            renderFragment(loadFragment(sd.frag, spec, 'env'), slots)
+          Fs.mkdirSync(Path.dirname(dest), { recursive: true })
+          Fs.writeFileSync(dest, content)
+        }
+      }
+    }
+  }
+}
+
+
+export {
+  env_gen,
+  ENV_FILES,
+  ENV_SRC,
+  KINDS,
+}

package/env/lambda/generate.ts

@@ -17,22 +17,28 @@ import { Jostraca, Project, File, Content } from 'jostraca'
 // the project's build actions). The fragment file's final newline is
 // dropped at load, so slot values fully control trailing bytes.
 
-// Package tm folder: compiled code lives at <pkg>/dist/env/lambda (three
+// Package tm root: compiled code lives at <pkg>/dist/env/lambda (three
 // levels down), but test transforms run the source at <pkg>/env/lambda
-// (two levels down) - probe both.
-const PKG_TM = [
-  Path.join(__dirname, '..', '..', '..', 'tm', 'lambda'),
-  Path.join(__dirname, '..', '..', 'tm', 'lambda'),
+// (two levels down) - probe both. Areas (tm/<area>/...) group fragment
+// sets: 'lambda' (the EnvLambda templates) and 'env' (per-environment
+// deployment templates).
+const PKG_TM_ROOT = [
+  Path.join(__dirname, '..', '..', '..', 'tm'),
+  Path.join(__dirname, '..', '..', 'tm'),
 ].find((p) => Fs.existsSync(p)) ||
-  Path.join(__dirname, '..', '..', '..', 'tm', 'lambda')
+  Path.join(__dirname, '..', '..', '..', 'tm')
 
+const PKG_TM = Path.join(PKG_TM_ROOT, 'lambda')
 
-function loadFragment(name: string, spec?: { tm?: string }): string {
+
+function loadFragment(
+  name: string, spec?: { tm?: string }, area: string = 'lambda'
+): string {
   const candidates = []
   if (spec?.tm) {
     candidates.push(Path.join(spec.tm, name))
   }
-  candidates.push(Path.join(PKG_TM, name))
+  candidates.push(Path.join(PKG_TM_ROOT, area, name))
 
   for (const c of candidates) {
     if (Fs.existsSync(c)) {
@@ -102,4 +108,5 @@ export {
   renderFragment,
   listFragments,
   PKG_TM,
+  PKG_TM_ROOT,
 }

package/env/web/web_gen.ts

@@ -0,0 +1,115 @@
+/* Copyright © 2026 Voxgig Ltd, MIT License. */
+
+// EnvWeb: generate the experimental web frontend - a Single Page App built
+// from web components on a client-side Seneca service bus (no React/Vue) -
+// plus the backend web runner and auth service it needs.
+//
+// Everything EnvWeb generates is CREATE-ONCE: a project owns its frontend
+// after generation (the SPA is a starting point users heavily customize).
+// Fragments live in @voxgig/build tm/web/ and are project-shadowable via
+// spec.tm (the project's tm/web folder), like every other template.
+//
+// The entity admin is model-driven at RUNTIME (it fetches the compiled
+// model.json), so the generated SPA adapts to any model with no
+// per-entity code generation.
+
+import Fs from 'fs'
+import Path from 'path'
+
+import { camelify } from '@voxgig/util'
+
+import { CoreConfShape } from '../../shape/conf'
+
+import { loadFragment, renderFragment } from '../lambda/generate'
+
+
+// File manifest: fragment (relative to tm/web) -> output path (relative to
+// the project root, which holds backend/ and web/). $$slots$$ in the
+// output path are rendered too.
+const WEB_FILES: { frag: string, out: string }[] = [
+  // Frontend SPA (web/)
+  { frag: 'web/package.json.frag', out: 'web/package.json' },
+  { frag: 'web/index.html.frag', out: 'web/index.html' },
+  { frag: 'web/playwright.config.js.frag', out: 'web/playwright.config.js' },
+  { frag: 'web/src/main.js.frag', out: 'web/src/main.js' },
+  { frag: 'web/src/bus.js.frag', out: 'web/src/bus.js' },
+  { frag: 'web/src/style.css.frag', out: 'web/src/style.css' },
+  { frag: 'web/src/cmp/app.js.frag', out: 'web/src/cmp/app.js' },
+  { frag: 'web/src/cmp/auth.js.frag', out: 'web/src/cmp/auth.js' },
+  { frag: 'web/src/cmp/admin.js.frag', out: 'web/src/cmp/admin.js' },
+  { frag: 'web/e2e/smoke.spec.js.frag', out: 'web/e2e/smoke.spec.js' },
+
+  // Backend web runner + auth service (backend/src/...)
+  { frag: 'backend/env/web/web.ts.frag', out: 'backend/src/env/web/web.ts' },
+  { frag: 'backend/srv/auth/auth-srv.ts.frag', out: 'backend/src/srv/auth/auth-srv.ts' },
+  { frag: 'backend/srv/auth/get_info.ts.frag', out: 'backend/src/srv/auth/get_info.ts' },
+  { frag: 'backend/srv/auth/signin_user.ts.frag', out: 'backend/src/srv/auth/signin_user.ts' },
+  { frag: 'backend/srv/auth/signout_user.ts.frag', out: 'backend/src/srv/auth/signout_user.ts' },
+  { frag: 'backend/srv/auth/load_auth.ts.frag', out: 'backend/src/srv/auth/load_auth.ts' },
+  { frag: 'backend/srv/auth/web_signin_user.ts.frag', out: 'backend/src/srv/auth/web_signin_user.ts' },
+  { frag: 'backend/srv/auth/web_signout_user.ts.frag', out: 'backend/src/srv/auth/web_signout_user.ts' },
+  { frag: 'backend/srv/auth/web_load_auth.ts.frag', out: 'backend/src/srv/auth/web_load_auth.ts' },
+]
+
+
+// Default seeded users (local testing only), rendered into the runner.
+const DEFAULT_USERS = [
+  { name: 'Alice Example', email: 'alice@example.com', password: 'alice-pass-01' },
+  { name: 'Bob Example', email: 'bob@example.com', password: 'bob-pass-01' },
+]
+
+
+// web_gen(model, spec): generate the frontend + backend web pieces into
+// the project. spec.root is the project root (parent of backend/); files
+// that already exist are left untouched (create-once).
+const web_gen = async (model: any, spec: {
+  root: string       // project root (holds backend/ and web/)
+  tm?: string        // project tm/web folder (fragment shadowing)
+  env?: any          // the model env entry (config: port, users)
+  force?: boolean    // overwrite existing files (default: create-once)
+}) => {
+
+  const core = CoreConfShape(model.main.conf.core)
+  const envdef = spec.env || {}
+
+  const users = envdef.users || DEFAULT_USERS
+  const seed = users[0] || DEFAULT_USERS[0]
+  const port = envdef.port ||
+    (model.main.conf.port && model.main.conf.port.backend) || 8080
+
+  const slots: Record<string, any> = {
+    name: core.name,
+    Name: camelify(core.name),
+    users: JSON.stringify(users, null, 2),
+    e2eport: envdef.e2eport || (port + 10),
+    seedEmail: seed.email,
+    seedPassword: seed.password,
+  }
+
+  const created: string[] = []
+  const skipped: string[] = []
+
+  for (const fd of WEB_FILES) {
+    const outrel = renderFragment(fd.out, slots)
+    const dest = Path.join(spec.root, outrel)
+
+    if (Fs.existsSync(dest) && !spec.force) {
+      skipped.push(outrel)
+      continue
+    }
+
+    const content = renderFragment(loadFragment(fd.frag, spec, 'web'), slots)
+    Fs.mkdirSync(Path.dirname(dest), { recursive: true })
+    Fs.writeFileSync(dest, content)
+    created.push(outrel)
+  }
+
+  return { created: created.sort(), skipped: skipped.sort() }
+}
+
+
+export {
+  web_gen,
+  WEB_FILES,
+  DEFAULT_USERS,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/build",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "main": "dist/build.js",
   "type": "commonjs",
   "types": "dist/build.d.ts",

package/tm/env/aws/README.md.frag

@@ -0,0 +1,9 @@
+# $$Name$$ - aws environment (Serverless Framework)
+
+    cd backend && npm run build
+    cd gen/env/aws && npx serverless deploy --stage $$stage$$
+
+serverless.yml composes the generated srv.yml (functions) and res.yml
+(resources); both are regenerated by model-build. Provider settings
+(region/stage/runtime) come from the model env entry - change them with
+the model, or eject env/aws/serverless.yml.frag for structural edits.

package/tm/env/aws/lambda.entry.ts.frag

@@ -0,0 +1,89 @@
+
+// $$Name$$ backend - AWS Lambda environment bootstrap (generated once;
+// this file is yours to edit). The generated handlers
+// (src/handler/lambda/<srv>.ts) call getSeneca() for a ready Seneca
+// instance wired for the Lambda + API Gateway path, configured by the
+// shared setup (src/env/shared/basic.ts).
+
+import Seneca from 'seneca'
+import { Live } from '@voxgig/system'
+
+import { basic, base } from '../shared/basic'
+
+import Pkg from '../../../package.json'
+import Model from '../../../model/model.json'
+
+
+const STAGE = process.env.STAGE || 'local'
+
+const Main = Model.main as any
+
+let seneca: any = null
+
+
+async function getSeneca(srvname: string, complete: Function): Promise<any> {
+  const { deep } = Seneca.util
+
+  if (null == seneca) {
+    const srv = Main.srv[srvname]
+
+    seneca = Seneca(deep(base.seneca, {
+      tag: srvname + '-$$name$$-' + STAGE + '@' + Pkg.version,
+      timeout: srv.env.lambda.timeout * 60 * 1000,
+    })).test()
+
+    seneca.context.model = Model
+    seneca.context.srvname = srvname
+    seneca.context.stage = STAGE
+    seneca.context.env = 'lambda'
+    seneca.context.pkg = Pkg
+
+    basic(seneca, { reload: { active: false } })
+
+    seneca
+      .use('gateway')
+      .use('gateway-lambda', {
+        auth: {
+          token: {
+            name: '$$name$$-auth',
+          },
+        },
+      })
+      .use('gateway-auth', {
+        spec: {
+          lambda_cookie: {
+            active: true,
+            token: {
+              name: '$$name$$-auth',
+            },
+            user: {
+              auth: true,
+              require: srv.user?.required ?? true,
+            },
+          },
+        },
+      })
+
+    seneca.use(Live, {
+      srv: {
+        name: srvname,
+        folder: __dirname + '/../../srv',
+      },
+    })
+
+    // Call ready() exactly once - a second ready() on an already-ready
+    // instance never resolves under seneca 4.0.0-rc4.
+    await seneca.ready()
+
+    if (complete) {
+      await complete(seneca)
+    }
+  }
+
+  return seneca
+}
+
+
+export {
+  getSeneca,
+}

package/tm/env/aws/serverless.yml.frag

@@ -0,0 +1,23 @@
+# $$Name$$ backend - Serverless Framework config (generated; customize via
+# tm/env/aws/). Composes the model-generated pieces: per-service function
+# definitions (srv.yml) and resources (res.yml) live beside this file and
+# are regenerated by model-build - edit the model, not those files.
+service: $$name$$-backend
+
+frameworkVersion: '4'
+
+provider:
+  name: aws
+  runtime: nodejs$$node$$.x
+  region: $$region$$
+  stage: ${opt:stage, '$$stage$$'}
+
+custom:
+  # res.yml derives the IAM role name suffix from this index.
+  index:
+    BasicLambdaRole: '01'
+
+functions: ${file(./srv.yml)}
+
+resources:
+  Resources: ${file(./res.yml)}

package/tm/env/azure/README.md.frag

@@ -0,0 +1,7 @@
+# $$Name$$ - azure environment (starting point)
+
+Azure Functions host config for the $$Name$$ backend. This is a starting
+point: Azure needs one function.json binding per exposed function - derive
+them from the service definitions the model generates for aws
+(gen/env/aws/srv.yml lists every handler and route). Eject
+env/azure/host.json.frag to customize.

package/tm/env/azure/entry.ts.frag

@@ -0,0 +1,49 @@
+
+// $$Name$$ backend - azure environment entry (generated once; this file is
+// yours to edit). STARTING POINT: an Azure Functions HTTP handler shape -
+// wire the Seneca gateway the way src/env/lambda/lambda.ts does for AWS.
+
+import Seneca from 'seneca'
+
+import { basic, base } from '../shared/basic'
+
+import Pkg from '../../../package.json'
+import Model from '../../../model/model.json'
+
+
+let seneca: any = null
+
+async function getSeneca(): Promise<any> {
+  if (null == seneca) {
+    seneca = Seneca(Seneca.util.deep(base.seneca, {
+      tag: '$$name$$-azure@' + Pkg.version,
+    })).test()
+
+    seneca.context.model = Model
+    seneca.context.env = 'azure'
+    seneca.context.pkg = Pkg
+
+    basic(seneca, { reload: { active: false } })
+
+    await seneca.ready()
+  }
+  return seneca
+}
+
+
+// Azure Functions v4 programming model handler (add @azure/functions and
+// register per-route handlers derived from the model - see
+// gen/env/aws/srv.yml for the full route list).
+async function handler(request: any, _context: any) {
+  await getSeneca()
+  return {
+    status: 501,
+    jsonBody: { ok: false, why: '$$name$$-backend azure entry not yet wired' },
+  }
+}
+
+
+export {
+  getSeneca,
+  handler,
+}

package/tm/env/azure/host.json.frag

@@ -0,0 +1,8 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": { "isEnabled": true }
+    }
+  }
+}

package/tm/env/basic/README.md.frag

@@ -0,0 +1,7 @@
+# $$Name$$ - basic environment (remote server)
+
+Runs the backend like local, on a plain server under systemd.
+
+    BASIC_HOST=user@host sh gen/env/basic/deploy.sh
+
+Installs to /opt/$$name$$/backend with unit $$name$$-backend.service.

package/tm/env/basic/backend.service.frag

@@ -0,0 +1,14 @@
+# systemd unit for the $$Name$$ backend (generated; customize via tm/env/basic/)
+[Unit]
+Description=$$Name$$ backend
+After=network.target
+
+[Service]
+WorkingDirectory=/opt/$$name$$/backend
+ExecStart=/usr/bin/node dist/env/local/local.js
+Restart=always
+Environment=NODE_ENV=production
+Environment=PORT=$$port$$
+
+[Install]
+WantedBy=multi-user.target

package/tm/env/basic/deploy.sh.frag

@@ -0,0 +1,13 @@
+#!/bin/sh
+# Deploy the $$Name$$ backend to a plain remote server (generated).
+# Usage: BASIC_HOST=user@host sh deploy.sh
+set -e
+: "${BASIC_HOST:?set BASIC_HOST=user@host}"
+cd "$(dirname "$0")/../../.."
+npm run build
+rsync -az --delete \
+  --exclude node_modules --exclude gen --exclude dist-test \
+  ./ "$BASIC_HOST:/opt/$$name$$/backend/"
+ssh "$BASIC_HOST" "cd /opt/$$name$$/backend && npm install --omit=dev \
+  && sudo cp gen/env/basic/$$name$$-backend.service /etc/systemd/system/ \
+  && sudo systemctl daemon-reload && sudo systemctl restart $$name$$-backend"

package/tm/env/cloudflare/README.md.frag

@@ -0,0 +1,7 @@
+# $$Name$$ - cloudflare environment (starting point)
+
+    cd gen/env/cloudflare && npx wrangler deploy
+
+The worker entry (src/env/cloudflare/worker.ts - yours to edit, wrangler
+bundles the TS directly) is a 501 stub: wire the Seneca gateway into the
+fetch handler (src/env/lambda/lambda.ts is the AWS model to follow).

package/tm/env/cloudflare/worker.ts.frag

@@ -0,0 +1,13 @@
+// $$Name$$ backend - Cloudflare Worker entry (generated once; this file is
+// yours to edit). STARTING POINT: Workers use a fetch handler rather than
+// a long-lived process - adapt the gateway wiring (src/env/lambda/lambda.ts
+// is the AWS equivalent) to route requests into Seneca here.
+
+export default {
+  async fetch(_request: Request, _env: unknown, _ctx: unknown) {
+    return new Response(JSON.stringify({
+      ok: false,
+      why: '$$name$$-backend worker entry not yet wired',
+    }), { status: 501, headers: { 'content-type': 'application/json' } })
+  },
+}

package/tm/env/cloudflare/wrangler.toml.frag

@@ -0,0 +1,7 @@
+# $$Name$$ backend - Cloudflare Workers config (generated; starting point)
+name = "$$name$$-backend"
+main = "../../../src/env/cloudflare/worker.ts"
+compatibility_date = "2026-01-01"
+
+[vars]
+NODE_ENV = "production"

package/tm/env/docker/Dockerfile.frag

@@ -0,0 +1,10 @@
+# $$Name$$ backend image (generated; customize via tm/env/docker/)
+FROM node:$$node$$-slim
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --omit=dev
+COPY model/model.json model/model.json
+COPY dist/ dist/
+ENV NODE_ENV=production
+EXPOSE $$port$$
+CMD ["node", "dist/env/local/local.js"]

package/tm/env/docker/README.md.frag

@@ -0,0 +1,7 @@
+# $$Name$$ - docker environment
+
+    cd backend && npm run build
+    docker compose -f gen/env/docker/compose.yml up --build
+
+Port $$port$$. The image runs the local (in-memory) runner; wire a real
+store before production use.

package/tm/env/docker/compose.yml.frag

@@ -0,0 +1,10 @@
+# $$Name$$ backend - docker compose (generated; customize via tm/env/docker/)
+services:
+  $$name$$-backend:
+    build:
+      context: ../../..
+      dockerfile: gen/env/docker/Dockerfile
+    ports:
+      - "$$port$$:$$port$$"
+    environment:
+      NODE_ENV: production

package/tm/env/local/README.md.frag

@@ -0,0 +1,7 @@
+# $$Name$$ - local environment
+
+Runs the backend in-process with the in-memory store:
+
+    sh gen/env/local/run.sh    # or: cd backend && npm run local
+
+Port: $$port$$. No external services required.

package/tm/env/local/run.sh.frag

@@ -0,0 +1,6 @@
+#!/bin/sh
+# $$Name$$ backend - local run (generated; customize via tm/env/local/)
+# In-process Seneca instance, in-memory store, port $$port$$.
+cd "$(dirname "$0")/../../.."
+export NODE_ENV=development
+exec npm run local