@voxgig/build 4.4.0 → 4.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/build",
-  "version": "4.4.0",
+  "version": "4.12.0",
   "main": "dist/build.js",
   "type": "commonjs",
   "types": "dist/build.d.ts",
@@ -19,12 +19,12 @@
   },
   "scripts": {
     "model-s01": "voxgig-model test/s01/model/model.aontu",
-    "test": "jest --coverage",
-    "test-some": "jest -t",
-    "test-watch": "jest --coverage --watchAll",
+    "test": "node --enable-source-maps --experimental-test-coverage --test-coverage-exclude='dist-test/test/**' --test-coverage-lines=95 --test-coverage-functions=85 --test-coverage-branches=78 --test-reporter=spec --test-reporter-destination=stdout --test-reporter=lcov --test-reporter-destination=coverage.lcov --test \"dist-test/test/**/*.test.js\"",
+    "test-some": "node --enable-source-maps --test --test-name-pattern=\"$npm_config_pattern\" \"dist-test/test/**/*.test.js\"",
+    "test-watch": "node --enable-source-maps --test --watch \"dist-test/test/**/*.test.js\"",
     "watch": "tsc -w -d",
-    "build": "tsc -d",
-    "clean": "rm -rf node_modules yarn.lock package-lock.json",
+    "build": "tsc -d && tsc -p test && cp -r test/fixture test/richmodel.js dist-test/test/",
+    "clean": "rm -rf dist dist-test node_modules yarn.lock package-lock.json",
     "reset": "npm run clean && npm i && npm run build && npm test",
     "repo-tag": "REPO_VERSION=`node -e \"console.log(require('./package').version)\"` && echo TAG: v$REPO_VERSION && git commit -a -m v$REPO_VERSION && git push && git tag v$REPO_VERSION && git push --tags;",
     "repo-publish": "npm run clean && npm i && npm run repo-publish-quick",
@@ -53,14 +53,11 @@
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.12",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "26.1.2",
     "@voxgig/model": "^9.2.4",
     "@voxgig/system": "^1.2.0",
     "esbuild": "^0.23.0",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.2",
     "typescript": "^5.5.3"
   }
 }

package/tm/web/backend/env/shared/seed.ts.frag

@@ -0,0 +1,23 @@
+// Demo/seed data for local development. The web runner already seeds the
+// predefined users; add your DOMAIN seed data here (projects, lists, items,
+// ...). Runs once per boot against the in-memory store. Create-once —
+// customise freely.
+
+export async function seedDemo(
+  seneca: any,
+  usersByEmail: Record<string, any>,
+): Promise<void> {
+  // Nothing seeded by default. Example (uncomment and adapt to your model):
+  //
+  // const owner = Object.values(usersByEmail)[0]
+  // if (!owner) return
+  // const existing = await seneca.entity('proj/project').list$({})
+  // if (existing.length > 0) return
+  // const now = Date.now()
+  // const p = await seneca.entity('proj/project')
+  //   .data$({ name: 'Example', owner_id: owner.id, t_c: now, t_m: now }).save$()
+  // await seneca.entity('proj/member')
+  //   .data$({ project_id: p.id, user_id: owner.id, role: 'owner',
+  //            owner_id: owner.id, t_c: now, t_m: now }).save$()
+}
+

package/tm/web/backend/env/web/api.ts.frag

@@ -0,0 +1,157 @@
+// The strict-JSON REST API endpoint (model main.api). Maps
+//
+//   GET    <prefix>/<version>/<zone>/<name>          -> list   (query -> q)
+//   GET    <prefix>/<version>/<zone>/<name>/<id>     -> load
+//   POST   <prefix>/<version>/<zone>/<name>          -> create
+//   PUT    <prefix>/<version>/<zone>/<name>/<id>     -> update
+//   DELETE <prefix>/<version>/<zone>/<name>/<id>     -> remove
+//
+// onto aim:api,on:ent messages (src/srv/api/on_ent.ts). Uniform semantic
+// paths and result shapes so an SDK can be generated (sdkgen); the
+// OpenAPI spec is generated from the model (gen/api/openapi.json).
+//
+// Authentication: API access keys - Authorization: Bearer vk_... - looked
+// up by sha-256 hash against sys/apikey and resolved to the owning user,
+// which becomes the request principal (so project-membership access
+// applies exactly as in the web app).
+
+import Crypto from 'node:crypto'
+import Path from 'node:path'
+
+// Result 'why' -> HTTP status.
+const STATUS: Record<string, number> = {
+  'not-authenticated': 401,
+  'forbidden': 403,
+  'unknown-entity': 404,
+  'not-found': 404,
+  'unknown-op': 405,
+  'read-only': 405,
+  'invalid-data': 400,
+  'project-required': 400,
+  'invalid-args': 400,
+}
+
+export function apiHandler(seneca: any, model: any) {
+  const api = (model.main && model.main.api) || {}
+  const version = api.version || 'v1'
+
+  return async function handle(req: any, res: any) {
+    res.type('application/json')
+
+    try {
+      // The generated OpenAPI spec (unauthenticated; from gen/api/).
+      if ('GET' === req.method && '/openapi.json' === req.path) {
+        return res.sendFile(Path.join(
+          __dirname, '..', '..', '..', 'gen', 'api', 'openapi.json'))
+      }
+      // The same spec as YAML - the format most codegen/SDK tools want.
+      if ('GET' === req.method && '/openapi.yaml' === req.path) {
+        res.type('application/yaml')
+        return res.sendFile(Path.join(
+          __dirname, '..', '..', '..', 'gen', 'api', 'openapi.yaml'))
+      }
+
+      // Path (relative to the mount prefix): /<version>/<zone>/<name>[/<id>]
+      const parts = String(req.path || '').split('/').filter((p: string) => '' !== p)
+      if (version !== parts[0] || parts.length < 3 || 4 < parts.length) {
+        return fail(res, 404, 'not-found', 'unknown route')
+      }
+      const ent = parts[1] + '/' + parts[2]
+      const id = parts[3]
+
+      const user = await authenticate(seneca, req)
+      if (null == user) {
+        return fail(res, 401, 'not-authenticated',
+          'provide a valid API key: Authorization: Bearer <key>')
+      }
+
+      const method = String(req.method || 'GET').toUpperCase()
+      let op: string | null = null
+      let body = undefined
+
+      if ('GET' === method) {
+        op = null == id ? 'list' : 'load'
+      }
+      else if ('POST' === method && null == id) {
+        op = 'create'
+        body = req.body
+      }
+      else if ('PUT' === method && null != id) {
+        op = 'update'
+        body = req.body
+      }
+      else if ('DELETE' === method && null != id) {
+        op = 'remove'
+      }
+      if (null == op) {
+        return fail(res, 405, 'unknown-op', 'method not supported on this path')
+      }
+
+      const out = await seneca.post('aim:api,on:ent', {
+        op,
+        ent,
+        id,
+        data: body,
+        q: 'list' === op ? Object.assign({}, req.query) : undefined,
+        custom$: { principal: { user } },
+      })
+
+      if (!out.ok) {
+        return fail(res, STATUS[out.why] || 500, out.why || 'failed',
+          out.message, out.details)
+      }
+
+      const status = 'create' === op ? 201 : 200
+      const result: any = {}
+      if (null != out.items) {
+        result.items = out.items
+      }
+      if (null != out.item) {
+        result.item = out.item
+      }
+      if ('remove' === op) {
+        result.ok = true
+        result.id = id
+      }
+      return res.status(status).send(result)
+    }
+    catch (e: any) {
+      return fail(res, 500, 'error', 'internal error')
+    }
+  }
+}
+
+function fail(res: any, status: number, code: string, message?: string, details?: any) {
+  const error: any = { code }
+  if (message) {
+    error.message = message
+  }
+  if (details) {
+    error.details = details
+  }
+  return res.status(status).send({ error })
+}
+
+// Resolve the Bearer API key to its owning user (the principal), or null.
+async function authenticate(seneca: any, req: any): Promise<any> {
+  const header = String(req.headers['authorization'] || '')
+  const m = header.match(/^Bearer\s+(\S+)$/i)
+  if (null == m) {
+    return null
+  }
+  const hash = Crypto.createHash('sha256').update(m[1]).digest('hex')
+  const keys = await seneca.entity('sys/apikey').list$({ hash })
+  const key = keys.find((k: any) => !k.revoked)
+  if (null == key) {
+    return null
+  }
+  const user = await seneca.entity('sys/user').load$(key.user_id)
+  if (null == user) {
+    return null
+  }
+  const d = user.data$(false)
+  delete d.pass
+  delete d.salt
+  return d
+}
+

package/tm/web/backend/env/web/web.ts.frag

@@ -1,6 +1,6 @@
 
 // Local web runner: the local in-memory backend plus an HTTP layer for
-// the SPA - express serving web/dist, the model, and a single seneca
+// the SPA - express serving the frontend dist, the model, and a single seneca
 // gateway endpoint (/seneca) that the browser-side Seneca bus posts
 // messages to (seneca-browser fetch transport). Cookie auth via
 // @seneca/gateway-auth (express_cookie): signin sets the todo-auth
@@ -18,6 +18,8 @@ import Seneca from 'seneca'
 import { Local } from '@voxgig/system'
 
 import { basic, base } from '../shared/basic'
+import { seedDemo } from '../shared/seed'
+import { apiHandler } from './api'
 
 import Pkg from '../../../package.json'
 import Model from '../../../model/model.json'
@@ -48,12 +50,25 @@ async function run() {
 
   basic(seneca)
 
+  // Dev REPL (@seneca/repl): poke the running system with messages -
+  //   npx seneca-repl telnet://localhost:<port.repl>
+  // Disable with REPL=false; override the port with REPL_PORT.
+  if ('false' !== process.env.REPL) {
+    seneca.use('repl', {
+      port: parseInt(process.env.REPL_PORT || '', 10) ||
+        (Model as any).main.conf.port.repl,
+    })
+  }
+
   seneca
     .use('gateway', {
-      // Allow auth + every service the model declares (aim:<srv>).
-      allow: Object.keys((Model as any).main.srv).reduce(
-        (a: any, n: string) => (a['aim:' + n] = true, a),
-        { 'aim:req,on:auth': true }),
+      // THE BROWSER SURFACE. Only aim:web is reachable from a browser:
+      // every message the SPA may send is declared in the model as an
+      // aim:web PROXY that forwards to the real service message. Service
+      // namespaces (aim:auth, aim:ent, ...) stay internal, so a browser
+      // cannot post one directly. API-key clients have their own proxy
+      // layer (aim:api behind the REST router, see ./api.ts).
+      allow: { 'aim:web': true },
     })
     .use('gateway-express', {
       // gateway-express sets/clears the auth cookie when a result carries
@@ -89,23 +104,42 @@ async function run() {
   await seneca.ready()
 
   // Seed the predefined users (idempotent per boot: in-memory store).
+  const usersByEmail: Record<string, any> = {}
   for (const u of USERS) {
     const res = await seneca.post('sys:user,register:user', u)
     if (!res.ok) {
       console.log('SEED-USER-FAILED', u.email, res.why)
     }
+    const got = await seneca.post('sys:user,get:user', { email: u.email })
+    if (got.ok && got.user) {
+      usersByEmail[u.email] = got.user
+    }
   }
 
+  // Seed demo projects/todolists/items (collaborative, one shared project).
+  await seedDemo(seneca, usersByEmail)
+
   const app = Express()
-  // web/ is a sibling of backend/; from dist/env/local go up to the
-  // project root, then web/dist.
+  // The frontend folder is a sibling of backend/; from dist/env/local go
+  // up to the project root, then into its dist. The folder name comes from
+  // the model (env web `dir`, default 'web'), so it stays in step if the
+  // project renames it.
   const webdist = Path.join(
-    __dirname, '..', '..', '..', '..', 'web', 'dist')
+    __dirname, '..', '..', '..', '..', '$$fe$$', 'dist')
 
   app
     .use(Express.json())
     .use(new (CookieParser as any)())
     .post('/seneca', seneca.export('gateway-express/handler'))
+
+  // The strict-JSON REST API (model main.api), if active. Mounted with
+  // use() so req.path inside the handler is relative to the prefix.
+  const apiconf = (Model as any).main.api
+  if (apiconf && false !== apiconf.active) {
+    app.use(apiconf.prefix || '/api', apiHandler(seneca, Model))
+  }
+
+  app
     .get('/model.json',
       (_req: any, res: any) => res.sendFile(
         Path.join(__dirname, '..', '..', '..', 'model', 'model.json')))
@@ -118,3 +152,4 @@ async function run() {
     version: Pkg.version,
   })
 }
+

package/tm/web/backend/srv/api/api-srv.ts.frag

@@ -0,0 +1,4 @@
+import { MakeSrv } from '@voxgig/system'
+
+module.exports = MakeSrv('api', require)
+

package/tm/web/backend/srv/api/expose.ts.frag

@@ -0,0 +1,33 @@
+// Which entities the REST API exposes (model main.api). Application
+// entities are exposed by default; the sys zone never is; per-entity
+// overrides live under main.api.ent.
+export function exposedCanon(model: any, canon: string): boolean {
+  const [zone, name] = String(canon).split('/')
+  const def = model && model.main && model.main.ent &&
+    model.main.ent[zone] && model.main.ent[zone][name]
+  if (null == def || 'sys' === zone) {
+    return false
+  }
+  const api = (model.main.api || {})
+  if (false === api.active) {
+    return false
+  }
+  const conf = (api.ent || {})[canon]
+  return !(conf && false === conf.active)
+}
+
+// All exposed canons, sorted (used by generators and get:info).
+export function exposedCanons(model: any): string[] {
+  const out: string[] = []
+  const zones = (model && model.main && model.main.ent) || {}
+  for (const zone of Object.keys(zones)) {
+    for (const name of Object.keys(zones[zone])) {
+      const canon = zone + '/' + name
+      if (exposedCanon(model, canon)) {
+        out.push(canon)
+      }
+    }
+  }
+  return out.sort()
+}
+

package/tm/web/backend/srv/api/get_info.ts.frag

@@ -0,0 +1,6 @@
+module.exports = function make_get_info() {
+  return async function get_info(this: any, _msg: any) {
+    return { ok: true, srv: 'api' }
+  }
+}
+

package/tm/web/backend/srv/api/on_ent.ts.frag

@@ -0,0 +1,124 @@
+import { exposedCanon } from './expose'
+
+// aim:api,on:ent  { op, ent:'zone/name', id?, data?, q? }
+// One REST operation on one entity. Validates the entity is exposed by
+// the API (model main.api) and the data against the GENERATED entity
+// shapes (valid_gen.ts - strict: unknown fields are rejected), then
+// delegates to the generic entity service (aim:ent,cmd:*), which
+// enforces membership access. The caller's principal (resolved from the
+// API key by the router) propagates via meta.custom.
+module.exports = function make_on_ent() {
+  const makeShapes = require('./valid_gen')
+  let shapes: any = null
+
+  return async function on_ent(this: any, msg: any) {
+    const seneca = this
+    const model = seneca.context.model
+
+    shapes = shapes || makeShapes(seneca.util.Gubu)
+
+    const op = String(msg.op || '')
+    const canon = String(msg.ent || '')
+
+    if (!exposedCanon(model, canon)) {
+      return { ok: false, why: 'unknown-entity' }
+    }
+
+    if ('list' === op) {
+      return relay(await seneca.post('aim:ent,cmd:list',
+        { ent: canon, q: coerceQ(model, canon, msg.q || {}) }))
+    }
+
+    if ('load' === op) {
+      const res = await seneca.post('aim:ent,cmd:load', { ent: canon, id: msg.id })
+      if (res.ok && null == res.item) {
+        return { ok: false, why: 'not-found' }
+      }
+      return relay(res)
+    }
+
+    if ('create' === op || 'update' === op) {
+      const shape = shapes[canon] && shapes[canon][op]
+      if (null == shape) {
+        return { ok: false, why: 'unknown-entity' }
+      }
+      let data = null == msg.data ? {} : msg.data
+      try {
+        data = shape(data)
+      }
+      catch (e: any) {
+        if ('shape' !== e.code) {
+          throw e
+        }
+        return {
+          ok: false, why: 'invalid-data', message: e.message,
+          details: (e.props || []).map((p: any) =>
+            ({ path: p.path, what: p.what, type: p.type })),
+        }
+      }
+      if ('update' === op) {
+        const existing = await seneca.post('aim:ent,cmd:load', { ent: canon, id: msg.id })
+        if (!existing.ok || null == existing.item) {
+          return { ok: false, why: existing.ok ? 'not-found' : existing.why }
+        }
+        data = Object.assign({}, existing.item.data$ ?
+          existing.item.data$(false) : existing.item, data, { id: msg.id })
+      }
+      return relay(await seneca.post('aim:ent,cmd:save', { ent: canon, item: data }))
+    }
+
+    if ('remove' === op) {
+      const existing = await seneca.post('aim:ent,cmd:load', { ent: canon, id: msg.id })
+      if (!existing.ok || null == existing.item) {
+        return { ok: false, why: existing.ok ? 'not-found' : existing.why }
+      }
+      return relay(await seneca.post('aim:ent,cmd:remove', { ent: canon, id: msg.id }))
+    }
+
+    return { ok: false, why: 'unknown-op' }
+  }
+}
+
+// Pass the ent service result through, stripping entity instances down
+// to plain data (strict JSON out).
+function relay(res: any) {
+  if (null == res || !res.ok) {
+    return res || { ok: false, why: 'failed' }
+  }
+  const out: any = { ok: true }
+  if (null != res.item) {
+    out.item = plain(res.item)
+  }
+  if (null != res.list) {
+    out.items = res.list.map(plain)
+  }
+  if (null != res.id) {
+    out.id = res.id
+  }
+  return out
+}
+
+function plain(item: any) {
+  return item && 'function' === typeof item.data$ ? item.data$(false) : item
+}
+
+// HTTP query values arrive as strings; coerce them to the field's kind
+// so exact-match filtering works (done=true, t_c=123, ...).
+function coerceQ(model: any, canon: string, q: any) {
+  const [zone, name] = canon.split('/')
+  const fields = (model.main.ent[zone][name] || {}).field || {}
+  const out: any = {}
+  for (const k of Object.keys(q)) {
+    const kind = fields[k] && fields[k].kind
+    let v: any = q[k]
+    if ('Number' === kind) {
+      v = Number(v)
+    }
+    else if ('Boolean' === kind) {
+      v = 'false' !== v && false !== v
+    }
+    out[k] = v
+  }
+  return out
+}
+

package/tm/web/backend/srv/auth/apikey_util.ts.frag

@@ -0,0 +1,10 @@
+// Shared helper for the apikey actions (not an action file).
+// Never expose the stored hash.
+export function publicKey(item: any) {
+  if (null == item) {
+    return null
+  }
+  const d = 'function' === typeof item.data$ ? item.data$(false) : item
+  return { id: d.id, name: d.name, prefix: d.prefix, revoked: !!d.revoked, t_c: d.t_c }
+}
+

package/tm/web/backend/srv/auth/auth-srv.ts.frag

@@ -2,3 +2,4 @@
 import { MakeSrv } from '@voxgig/system'
 
 module.exports = MakeSrv('auth', require)
+

package/tm/web/backend/srv/auth/change_pass.ts.frag

@@ -0,0 +1,12 @@
+// aim:auth,change:pass — change the current user's password via @seneca/user.
+module.exports = function make_change_pass() {
+  return async function change_pass(this: any, msg: any) {
+    const res = await this.post('sys:user,change:pass', {
+      user_id: msg.user_id,
+      password: msg.password,
+      repeat: msg.repeat,
+    })
+    return res.ok ? { ok: true } : { ok: false, why: res.why || 'change-failed' }
+  }
+}
+

package/tm/web/backend/srv/auth/create_apikey.ts.frag

@@ -0,0 +1,33 @@
+import Crypto from 'node:crypto'
+
+import { publicKey } from './apikey_util'
+
+// aim:auth,create:apikey  { user_id, name }
+// Create an API access key for the user. The raw key is returned ONCE
+// (never stored): only its sha-256 hash is kept, plus a short prefix for
+// display. Keys authenticate REST API calls (Authorization: Bearer).
+module.exports = function make_create_apikey() {
+  return async function create_apikey(this: any, msg: any) {
+    const seneca = this
+    const user_id = String(msg.user_id || '')
+    const name = String(msg.name || '').trim()
+    if ('' === user_id || '' === name) {
+      return { ok: false, why: 'invalid-args' }
+    }
+
+    const key = 'vk_' + Crypto.randomBytes(24).toString('hex')
+    const hash = Crypto.createHash('sha256').update(key).digest('hex')
+
+    const item = await seneca.entity('sys/apikey').data$({
+      user_id,
+      name,
+      hash,
+      prefix: key.slice(0, 8),
+      revoked: false,
+      t_c: Date.now(),
+    }).save$()
+
+    return { ok: !!item, key, item: publicKey(item) }
+  }
+}
+

package/tm/web/backend/srv/auth/get_info.ts.frag

@@ -3,3 +3,4 @@ module.exports = function make_get_info() {
     return { ok: true, srv: 'auth' }
   }
 }
+

package/tm/web/backend/srv/auth/list_apikey.ts.frag

@@ -0,0 +1,15 @@
+import { publicKey } from './apikey_util'
+
+// aim:auth,list:apikey  { user_id }
+// List the user's API keys (hashes never leave the service).
+module.exports = function make_list_apikey() {
+  return async function list_apikey(this: any, msg: any) {
+    const user_id = String(msg.user_id || '')
+    if ('' === user_id) {
+      return { ok: false, why: 'invalid-args' }
+    }
+    const list = await this.entity('sys/apikey').list$({ user_id })
+    return { ok: true, items: list.map(publicKey) }
+  }
+}
+

package/tm/web/backend/srv/auth/load_auth.ts.frag

@@ -1,6 +1,15 @@
+import { publicUser } from './user_util'
+
+// Load the auth state for a user id. The user is projected to safe
+// fields (never the password hash or salt) - see user_util.
 module.exports = function make_load_auth() {
   return async function load_auth(this: any, msg: any) {
     const user = await this.entity('sys/user').load$(msg.user_id)
-    return { ok: !!user, state: user ? 'signedin' : 'signedout', user }
+    return {
+      ok: !!user,
+      state: user ? 'signedin' : 'signedout',
+      user: publicUser(user),
+    }
   }
 }
+

package/tm/web/backend/srv/auth/remind_pass.ts.frag

@@ -0,0 +1,35 @@
+// aim:auth,remind:pass — password reminder. Creates a reset code but does
+// NOT actually send an email (this is a demo); it logs what WOULD be sent.
+// Always returns ok, regardless of whether the email exists, to avoid
+// leaking which addresses are registered.
+module.exports = function make_remind_pass() {
+  return async function remind_pass(this: any, msg: any) {
+    const email = String(msg.email || '').trim()
+    if ('' === email) {
+      return { ok: true }
+    }
+
+    const found = await this.post('sys:user,get:user', { email })
+    if (found.ok && found.user) {
+      let code = '(reset-code)'
+      try {
+        const v = await this.post('sys:user,make:verify', {
+          user_id: found.user.id,
+          kind: 'pass',
+        })
+        code = (v && ((v.verify && (v.verify.id || v.verify.code)) || v.id)) || code
+      }
+      catch (e) {
+        // best-effort; the reminder is a stub
+      }
+
+      // IMPORTANT: no email is actually sent — just record what would be.
+      this.log.info('password-reminder', { to: email, code, sent: false })
+      // eslint-disable-next-line no-console
+      console.log('[PASSWORD-REMINDER] (not sent) to=' + email + ' reset-code=' + code)
+    }
+
+    return { ok: true }
+  }
+}
+

package/tm/web/backend/srv/auth/revoke_apikey.ts.frag

@@ -0,0 +1,23 @@
+import { publicKey } from './apikey_util'
+
+// aim:auth,revoke:apikey  { user_id, id }
+// Revoke one of the user's API keys. The record is kept (audit trail);
+// revoked keys fail REST authentication immediately.
+module.exports = function make_revoke_apikey() {
+  return async function revoke_apikey(this: any, msg: any) {
+    const seneca = this
+    const user_id = String(msg.user_id || '')
+    const id = String(msg.id || '')
+    if ('' === user_id || '' === id) {
+      return { ok: false, why: 'invalid-args' }
+    }
+    const item = await seneca.entity('sys/apikey').load$(id)
+    if (null == item || item.user_id !== user_id) {
+      return { ok: false, why: 'not-found' }
+    }
+    item.revoked = true
+    const saved = await item.save$()
+    return { ok: !!saved, item: publicKey(saved) }
+  }
+}
+