lecodes-cli 2.2.13 → 2.3.0

package/src/dev/backendWorker.ts

@@ -4,11 +4,12 @@ import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { format } from "node:util"
 import {
-  createAuthHost, createFilesHost, createInvoker, createSubscribeGuard, describeServer, loadServerModules, runSeed,
-  setChannelPublisher, setDbTransport, type AuthHost, type Heic, type LoadedServer, type Sharp,
+  createAuthHost, createFilesHost, createInvoker, createPushHost, createSubscribeGuard, describeServer, loadServerModules, runSeed,
+  setChannelPublisher, setDbTransport, type AuthHost, type Heic, type LoadedServer, type PushRelay, type Sharp,
 } from "lecodes-sdk/server"
 import { loadPeer } from "../hosts/peerInstall"
-import type { FromWorker, LogLevel, ToWorker } from "./localBackend"
+import { ApiError, sendPush } from "../platform/api"
+import type { FromWorker, LogLevel, PushSender, ToWorker } from "./localBackend"
 
 /*
  * The process a project's server bundle runs in under `lecodes dev` — the local twin of the runner's
@@ -96,6 +97,21 @@ const openDb = async (dir: string, filesDir: string, schema: string): Promise<st
   }
 }
 
+/** Push notifications go out through the platform's send route on the developer's own login, as `lecodes pn send`
+ *  does — a project push key is never needed here. The platform's 404 for an address it knows no more
+ *  (`unknown_addresses`) is answered as `unknown`, for the host to drop and send the rest again. */
+const pushRelay = (sender: PushSender): PushRelay => async (to, message) => {
+  try {
+    return await sendPush(sender.apiUrl, sender.token, sender.uuid, { to, ...message })
+  } catch (e) {
+    const body = e instanceof ApiError ? e.body as { code?: string, addresses?: unknown } | null : null
+    if (body?.code === "unknown_addresses" && Array.isArray(body.addresses)) {
+      return { sent: 0, failed: [], unknown: body.addresses.filter((a): a is string => typeof a === "string") }
+    }
+    throw new Error(`push: the platform refused the send: ${(e as Error).message}`)
+  }
+}
+
 const load = async (m: Extract<ToWorker, { t: "load" }>) => {
   const noDb = () => { throw new Error("db: the database is not open yet — query it inside an endpoint, not while the module loads") }
   setDbTransport({ exec: (op) => (db ?? noDb()).exec(op), batch: (ops) => (db ?? noDb()).batch(ops) })
@@ -116,6 +132,13 @@ const load = async (m: Extract<ToWorker, { t: "load" }>) => {
     log: (level, text) => post({ t: "log", level, text }),
   })
   authHost.install()
+  // Push channels: a user's devices are the sessions of the db with sign-in; the notifications go out through the platform
+  // when this checkout is linked and the developer is logged in.
+  createPushHost({
+    db: server.dbs.find(d => d.$auth) ?? null,
+    relay: m.push ? pushRelay(m.push) : null,
+    log: (level, text) => post({ t: "log", level, text }),
+  }).install()
   const auth = authHost.enabled ? authHost : null
   const onError = (id: string, e: unknown) => post({ t: "log", level: "error", text: `${id}: ${(e as Error)?.stack ?? e}` })
   // Stored files (`t.file()`): rows in the database, bytes in the folder beside it

package/src/dev/localBackend.ts

@@ -25,7 +25,7 @@ export type LogLevel = "log" | "info" | "warn" | "error" | "debug"
 type Ctx = Omit<RequestContext, "id">
 
 export type ToWorker =
-  | { t: "load", code: string, dbDir: string, filesDir: string, root: string }
+  | { t: "load", code: string, dbDir: string, filesDir: string, root: string, push: PushSender | null }
   | { t: "invoke", req: number, id: string, args: unknown[], ctx: Ctx }
   | { t: "subscribe", req: number, ch: string, args: unknown[], ctx: Ctx }
   | { t: "stop" }
@@ -37,8 +37,13 @@ export type FromWorker =
   | { t: "publish", ch: string, group: ChannelGroup | null, data: unknown }
   | { t: "log", level: LogLevel, text: string }
 
+/** How `pushChannel.send` reaches the platform's sender from this machine: the linked project and the developer's
+ *  own login (what `lecodes pn send` sends with). `null` = not linked or not logged in: sends answer 0, said once. */
+export type PushSender = { apiUrl: string, token: string, uuid: string }
+
 export type LocalBackendOptions = {
   root: string
+  push?: PushSender | null
   /** The database's folder (default `.lecodes/db`). */
   dbDir?: string
   /** The stored files' folder (`t.file()`; default: beside the database — `.lecodes/files`). */
@@ -147,7 +152,7 @@ export const startLocalBackend = (options: LocalBackendOptions): LocalBackend =>
         if (!closed) log(`[server:error] the server process exited (${status ?? "killed"}) — it starts again with the next call`)
       }
     })
-    child.send({ t: "load", code: bundle, dbDir, filesDir, root: options.root } satisfies ToWorker)
+    child.send({ t: "load", code: bundle, dbDir, filesDir, root: options.root, push: options.push ?? null } satisfies ToWorker)
   })
 
   const stop = async (l: Live) => {

package/src/dev/projectBackend.ts

@@ -3,7 +3,8 @@ import { join, relative } from "node:path"
 import { createChannelHub, fileResponse, isMultipart, receiveUploads, UploadError, type Upload } from "lecodes-sdk/server"
 import { compileServer, hasServerFiles, type CompileEntry } from "../compile/projectCompile"
 import { loadPeer } from "../hosts/peerInstall"
-import { LECODES_DIR } from "../project/manifest"
+import { LECODES_DIR, readManifest } from "../project/manifest"
+import { session } from "../commands/shared"
 import { readAppConfigAt } from "../commands/app/shared"
 import { filesDirOf, startLocalBackend, type LocalBackend } from "./localBackend"
 import { serve, type Served, type Socket, type SocketHandlers } from "./serve"
@@ -73,7 +74,12 @@ export const createProjectBackend = (options: ProjectBackendOptions): ProjectBac
       : Promise.resolve({ ok: false as const, status: 404, message: "The project has no server files" }),
   })
   const sockets = new Set<Socket>()
-  const start = () => startLocalBackend({ root, dbDir, log, onPublish: (ch, group, data) => hub.publish("", ch, group, data) })
+  // `pushChannel.send` reaches the platform's sender through the developer's own login when the checkout is linked —
+  // the way `lecodes pn send` sends; a project standing alone, or no login, sends nothing (said once in the console)
+  const push = (() => {
+    try { const { apiUrl, token } = session(); return { apiUrl, token, uuid: readManifest(root).uuid } } catch { return null }
+  })()
+  const start = () => startLocalBackend({ root, dbDir, log, push, onPublish: (ch, group, data) => hub.publish("", ch, group, data) })
 
   const envelope = (body: unknown) => new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json", "cache-control": "no-store", ...CORS } })
 

package/src/platform/api.ts

@@ -353,6 +353,8 @@ export const deleteDesignCommentMessage = (
 export type PushSendPayload = {
   to?: string[]
   users?: string[]
+  /** The server's push channel the notification is of (`<path>#<export>`): the app's side hears each channel's own. */
+  channel?: string
   title: string
   body?: string
   url?: string

package/src/project/ignore.ts

@@ -1,164 +1,164 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-
-/*
- * `.lecodesignore` support — keeps scratch files (temp probes, render screenshots, logs) out of
- * `status` / `push` so they never land in a checkpoint. Syntax is a practical subset of .gitignore:
- *   - blank lines and `# comments` are skipped
- *   - `!pattern` re-includes something a previous pattern ignored
- *   - a trailing `/` matches directories only
- *   - a leading `/` (or any embedded `/`) anchors the pattern to the project root
- *   - `*` matches within a path segment, `**` across segments, `?` a single char
- *   - a slash-free pattern (e.g. `_*`, `*.png`) matches a basename at any depth
- *
- * IMPORTANT: ignores apply to UNTRACKED files only. A file already in the project (recorded in the
- * manifest) is always tracked, even if it matches a pattern — so ignoring `*.png` can never make an
- * existing image asset silently disappear from the project. Pruning happens in `scanLocal`.
- */
-
-export type IgnoreMatcher = (key: string, isDir: boolean) => boolean
-
-type Rule = { re: RegExp, negate: boolean, dirOnly: boolean }
-
-// Always applied, even with no .lecodesignore — only patterns that are never real project assets, so
-// they're safe as invisible defaults. Everything asset-shaped (*.png, *.json, …) is opt-in via the
-// file written at clone time (see DEFAULT_IGNORE_FILE). `.artifacts/` is `lecodes test`'s
-// failure-frame dump dir (tests/.artifacts/) — regenerated scratch, never a project asset.
-// `dist/` is `lecodes app build desktop`'s default output (<root>/dist/<slug>, appDesktop.ts) —
-// same class, but it must be ignored for a second, load-bearing reason: that folder holds a COPY of
-// the host's runtime assets (lit.filamat, uberarchive.bin, …). Collected as project assets they get
-// staged next to the bundle, and onFetchLocal searches the bundle's dir BEFORE the host's assets dir
-// (main.cpp) — so the copy shadows the host's own. Harmless while every host was OpenGL and the
-// bytes matched; fatal once a build output can come from the Vulkan host, where the shadowing
-// lit.filamat is SPIR-V and Filament aborts with "not built for any of the OpenGL backend's
-// supported shader languages".
-// `.env` / `.env.*`: the project's LECODES_* config (projectEnv.ts) — it holds tokens and keystore
-// passwords, so it never leaves the machine whatever .lecodesignore says.
-// `.lightmap/` = a bake's float debug layers (`lecodes lightmap bake --debug-dir`): gigabytes the compile scan must never read
-const BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store", ".artifacts/", "dist/", ".env", ".env.*", ".lightmap/"]
-
-/** Template `.lecodesignore` written on clone — the explicit, editable "what we don't push" list. */
-export const DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
-# Only untracked files are affected — assets already in the project stay tracked
-# even if they match a pattern. Built-in defaults (node_modules, _*, *.log, .artifacts)
-# always apply.
-
-# Render / preview outputs (the default \`lecodes render --png\` target)
-screenshot.png
-shots/
-
-# Design-board comments live on the platform; design/comments/ is the local mirror of the
-# open ones (\`lecodes design comments pull\`) — read by Claude, but pushing it back as
-# project files would only duplicate the database.
-design/comments/
-
-# Image & other binary assets ARE pushed by default — they're real project resources.
-# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
-# *.png
-
-# Local notes & dumps (uncomment to ignore)
-# *.json
-# notes.md
-`
-
-/** Translate a glob (one path segment's worth of `*`/`?`/`**`) into a regex fragment. */
-const translate = (glob: string): string => {
-  let re = ""
-  for (let i = 0; i < glob.length; i++) {
-    const ch = glob[i]
-    if (ch === "*") {
-      if (glob[i + 1] === "*") { re += ".*"; i++; if (glob[i + 1] === "/") i++ } // `**/` spans dirs
-      else re += "[^/]*"
-    } else if (ch === "?") re += "[^/]"
-    else if (ch === "/") re += "/"
-    else if ("\\^$.|+()[]{}".includes(ch)) re += "\\" + ch
-    else re += ch
-  }
-  return re
-}
-
-const compile = (raw: string): Rule | null => {
-  let p = raw.trim()
-  if (!p || p.startsWith("#")) return null
-  let negate = false
-  if (p.startsWith("!")) { negate = true; p = p.slice(1) }
-  let dirOnly = false
-  if (p.endsWith("/")) { dirOnly = true; p = p.slice(0, -1) }
-  const anchored = p.startsWith("/") || p.includes("/")
-  if (p.startsWith("/")) p = p.slice(1)
-  if (!p) return null
-  const body = translate(p)
-  // `(/.*)?$` lets a directory pattern also match files nested under it, matching gitignore behavior
-  // even without relying on directory pruning.
-  const re = anchored ? new RegExp("^/" + body + "(/.*)?$") : new RegExp("(^|/)" + body + "(/.*)?$")
-  return { re, negate, dirOnly }
-}
-
-const buildMatcher = (rules: Rule[]): IgnoreMatcher => (key, isDir) => {
-  let ignored = false
-  for (const r of rules) {
-    if (r.dirOnly && !isDir) continue // a `foo/` rule only matches dirs directly (files via prune)
-    if (r.re.test(key)) ignored = !r.negate
-  }
-  return ignored
-}
-
-/** Compile a standalone glob list (same syntax as .lecodesignore lines, including `!` re-includes)
- *  into a file-path matcher — used for app.json's `resources.remote` patterns. */
-export const buildGlobMatcher = (patterns: string[]): ((path: string) => boolean) => {
-  // Matching is over FILE paths — normalize `videos/` (dir-only, would match nothing here) to
-  // `videos`, whose `(/.*)?$` tail matches everything under the directory.
-  const rules = patterns.map((p) => compile(p.trim().replace(/\/+$/, ""))).filter((r): r is Rule => r !== null)
-  const match = buildMatcher(rules)
-  // Anchored rules compile to `^/…` — they expect the canonical leading-slash key form.
-  return (path) => match(path.startsWith("/") ? path : "/" + path, false)
-}
-
-/** Read `<root>/.lecodesignore` (if any) and combine with the built-in defaults into a matcher. */
-export const loadIgnore = (root: string): IgnoreMatcher => {
-  const lines = [...BUILTIN_PATTERNS]
-  const file = join(root, ".lecodesignore")
-  if (existsSync(file)) {
-    try { lines.push(...readFileSync(file, "utf8").split(/\r?\n/)) } catch { /* unreadable → defaults only */ }
-  }
-  const rules = lines.map(compile).filter((r): r is Rule => r !== null)
-  return buildMatcher(rules)
-}
-
-/** Write the template `.lecodesignore` if the project doesn't have one yet (used on clone). */
-export const writeDefaultIgnore = (root: string) => {
-  const file = join(root, ".lecodesignore")
-  if (!existsSync(file)) writeFileSync(file, DEFAULT_IGNORE_FILE)
-}
-
-/* `.gitignore` for the project's OWN git repo. `.lecodes/` is per-checkout state — regenerable IDE
- * types (`lecodes update`) + `manifest.json`, this machine's push cursor (baseHeadId + per-file shas).
- * Committing it makes collaborators fight over the cursor and ship stale types, so every scaffold
- * path (init / clone / link) makes sure it's ignored. Render outputs mirror DEFAULT_IGNORE_FILE. */
-export const DEFAULT_GITIGNORE = `# LeCodes per-checkout state: generated IDE types + this machine's sync cursor
-# (.lecodes/manifest.json). Regenerate with \`lecodes update\` / re-attach with \`lecodes link\`.
-.lecodes/
-
-# Render / preview outputs and test failure frames
-screenshot.png
-shots/
-tests/.artifacts/
-tests/.shots/
-
-node_modules/
-
-dist/
-`
-
-/** Create `.gitignore` if missing; if it exists but doesn't ignore `.lecodes/`, append that rule.
- * Returns what happened so callers can log it ("created" | "updated" | null). */
-export const ensureGitignore = (root: string): "created" | "updated" | null => {
-  const file = join(root, ".gitignore")
-  if (!existsSync(file)) { writeFileSync(file, DEFAULT_GITIGNORE); return "created" }
-  const text = readFileSync(file, "utf8")
-  const covered = text.split(/\r?\n/).some(l => /^\/?\.lecodes\/?\s*$/.test(l.trim()))
-  if (covered) return null
-  const sep = text.length === 0 || text.endsWith("\n") ? "" : "\n"
-  writeFileSync(file, `${text}${sep}\n# LeCodes per-checkout state (generated types + sync cursor) — not source\n.lecodes/\n`)
-  return "updated"
-}
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+
+/*
+ * `.lecodesignore` support — keeps scratch files (temp probes, render screenshots, logs) out of
+ * `status` / `push` so they never land in a checkpoint. Syntax is a practical subset of .gitignore:
+ *   - blank lines and `# comments` are skipped
+ *   - `!pattern` re-includes something a previous pattern ignored
+ *   - a trailing `/` matches directories only
+ *   - a leading `/` (or any embedded `/`) anchors the pattern to the project root
+ *   - `*` matches within a path segment, `**` across segments, `?` a single char
+ *   - a slash-free pattern (e.g. `_*`, `*.png`) matches a basename at any depth
+ *
+ * IMPORTANT: ignores apply to UNTRACKED files only. A file already in the project (recorded in the
+ * manifest) is always tracked, even if it matches a pattern — so ignoring `*.png` can never make an
+ * existing image asset silently disappear from the project. Pruning happens in `scanLocal`.
+ */
+
+export type IgnoreMatcher = (key: string, isDir: boolean) => boolean
+
+type Rule = { re: RegExp, negate: boolean, dirOnly: boolean }
+
+// Always applied, even with no .lecodesignore — only patterns that are never real project assets, so
+// they're safe as invisible defaults. Everything asset-shaped (*.png, *.json, …) is opt-in via the
+// file written at clone time (see DEFAULT_IGNORE_FILE). `.artifacts/` is `lecodes test`'s
+// failure-frame dump dir (tests/.artifacts/) — regenerated scratch, never a project asset.
+// `dist/` is `lecodes app build desktop`'s default output (<root>/dist/<slug>, appDesktop.ts) —
+// same class, but it must be ignored for a second, load-bearing reason: that folder holds a COPY of
+// the host's runtime assets (lit.filamat, uberarchive.bin, …). Collected as project assets they get
+// staged next to the bundle, and onFetchLocal searches the bundle's dir BEFORE the host's assets dir
+// (main.cpp) — so the copy shadows the host's own. Harmless while every host was OpenGL and the
+// bytes matched; fatal once a build output can come from the Vulkan host, where the shadowing
+// lit.filamat is SPIR-V and Filament aborts with "not built for any of the OpenGL backend's
+// supported shader languages".
+// `.env` / `.env.*`: the project's LECODES_* config (projectEnv.ts) — it holds tokens and keystore
+// passwords, so it never leaves the machine whatever .lecodesignore says.
+// `.lightmap/` = a bake's float debug layers (`lecodes lightmap bake --debug-dir`): gigabytes the compile scan must never read
+const BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store", ".artifacts/", "dist/", ".env", ".env.*", ".lightmap/"]
+
+/** Template `.lecodesignore` written on clone — the explicit, editable "what we don't push" list. */
+export const DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
+# Only untracked files are affected — assets already in the project stay tracked
+# even if they match a pattern. Built-in defaults (node_modules, _*, *.log, .artifacts)
+# always apply.
+
+# Render / preview outputs (the default \`lecodes render --png\` target)
+screenshot.png
+shots/
+
+# Design-board comments live on the platform; design/comments/ is the local mirror of the
+# open ones (\`lecodes design comments pull\`) — read by Claude, but pushing it back as
+# project files would only duplicate the database.
+design/comments/
+
+# Image & other binary assets ARE pushed by default — they're real project resources.
+# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
+# *.png
+
+# Local notes & dumps (uncomment to ignore)
+# *.json
+# notes.md
+`
+
+/** Translate a glob (one path segment's worth of `*`/`?`/`**`) into a regex fragment. */
+const translate = (glob: string): string => {
+  let re = ""
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i]
+    if (ch === "*") {
+      if (glob[i + 1] === "*") { re += ".*"; i++; if (glob[i + 1] === "/") i++ } // `**/` spans dirs
+      else re += "[^/]*"
+    } else if (ch === "?") re += "[^/]"
+    else if (ch === "/") re += "/"
+    else if ("\\^$.|+()[]{}".includes(ch)) re += "\\" + ch
+    else re += ch
+  }
+  return re
+}
+
+const compile = (raw: string): Rule | null => {
+  let p = raw.trim()
+  if (!p || p.startsWith("#")) return null
+  let negate = false
+  if (p.startsWith("!")) { negate = true; p = p.slice(1) }
+  let dirOnly = false
+  if (p.endsWith("/")) { dirOnly = true; p = p.slice(0, -1) }
+  const anchored = p.startsWith("/") || p.includes("/")
+  if (p.startsWith("/")) p = p.slice(1)
+  if (!p) return null
+  const body = translate(p)
+  // `(/.*)?$` lets a directory pattern also match files nested under it, matching gitignore behavior
+  // even without relying on directory pruning.
+  const re = anchored ? new RegExp("^/" + body + "(/.*)?$") : new RegExp("(^|/)" + body + "(/.*)?$")
+  return { re, negate, dirOnly }
+}
+
+const buildMatcher = (rules: Rule[]): IgnoreMatcher => (key, isDir) => {
+  let ignored = false
+  for (const r of rules) {
+    if (r.dirOnly && !isDir) continue // a `foo/` rule only matches dirs directly (files via prune)
+    if (r.re.test(key)) ignored = !r.negate
+  }
+  return ignored
+}
+
+/** Compile a standalone glob list (same syntax as .lecodesignore lines, including `!` re-includes)
+ *  into a file-path matcher — used for app.json's `resources.remote` patterns. */
+export const buildGlobMatcher = (patterns: string[]): ((path: string) => boolean) => {
+  // Matching is over FILE paths — normalize `videos/` (dir-only, would match nothing here) to
+  // `videos`, whose `(/.*)?$` tail matches everything under the directory.
+  const rules = patterns.map((p) => compile(p.trim().replace(/\/+$/, ""))).filter((r): r is Rule => r !== null)
+  const match = buildMatcher(rules)
+  // Anchored rules compile to `^/…` — they expect the canonical leading-slash key form.
+  return (path) => match(path.startsWith("/") ? path : "/" + path, false)
+}
+
+/** Read `<root>/.lecodesignore` (if any) and combine with the built-in defaults into a matcher. */
+export const loadIgnore = (root: string): IgnoreMatcher => {
+  const lines = [...BUILTIN_PATTERNS]
+  const file = join(root, ".lecodesignore")
+  if (existsSync(file)) {
+    try { lines.push(...readFileSync(file, "utf8").split(/\r?\n/)) } catch { /* unreadable → defaults only */ }
+  }
+  const rules = lines.map(compile).filter((r): r is Rule => r !== null)
+  return buildMatcher(rules)
+}
+
+/** Write the template `.lecodesignore` if the project doesn't have one yet (used on clone). */
+export const writeDefaultIgnore = (root: string) => {
+  const file = join(root, ".lecodesignore")
+  if (!existsSync(file)) writeFileSync(file, DEFAULT_IGNORE_FILE)
+}
+
+/* `.gitignore` for the project's OWN git repo. `.lecodes/` is per-checkout state — regenerable IDE
+ * types (`lecodes update`) + `manifest.json`, this machine's push cursor (baseHeadId + per-file shas).
+ * Committing it makes collaborators fight over the cursor and ship stale types, so every scaffold
+ * path (init / clone / link) makes sure it's ignored. Render outputs mirror DEFAULT_IGNORE_FILE. */
+export const DEFAULT_GITIGNORE = `# LeCodes per-checkout state: generated IDE types + this machine's sync cursor
+# (.lecodes/manifest.json). Regenerate with \`lecodes update\` / re-attach with \`lecodes link\`.
+.lecodes/
+
+# Render / preview outputs and test failure frames
+screenshot.png
+shots/
+tests/.artifacts/
+tests/.shots/
+
+node_modules/
+
+dist/
+`
+
+/** Create `.gitignore` if missing; if it exists but doesn't ignore `.lecodes/`, append that rule.
+ * Returns what happened so callers can log it ("created" | "updated" | null). */
+export const ensureGitignore = (root: string): "created" | "updated" | null => {
+  const file = join(root, ".gitignore")
+  if (!existsSync(file)) { writeFileSync(file, DEFAULT_GITIGNORE); return "created" }
+  const text = readFileSync(file, "utf8")
+  const covered = text.split(/\r?\n/).some(l => /^\/?\.lecodes\/?\s*$/.test(l.trim()))
+  if (covered) return null
+  const sep = text.length === 0 || text.endsWith("\n") ? "" : "\n"
+  writeFileSync(file, `${text}${sep}\n# LeCodes per-checkout state (generated types + sync cursor) — not source\n.lecodes/\n`)
+  return "updated"
+}