@nanobpm/urban 0.20.0 → 0.22.0

package/src/runtime/adapters/deno.ts

@@ -14,6 +14,24 @@ import type {
   SqliteDb,
 } from "../core/host.ts";
 
+type SqliteParam = string | number | bigint | Uint8Array | null;
+
+function sqliteParams(params: unknown[]): SqliteParam[] {
+  return params.map((param) => {
+    if (
+      param === null ||
+      typeof param === "string" ||
+      typeof param === "number" ||
+      typeof param === "bigint" ||
+      param instanceof Uint8Array
+    ) {
+      return param;
+    }
+    if (typeof param === "boolean") return param ? 1 : 0;
+    throw new TypeError(`unsupported SQLite parameter type: ${typeof param}`);
+  });
+}
+
 interface DenoHttpServer {
   finished: Promise<void>;
   shutdown(): Promise<void>;
@@ -84,7 +102,8 @@ export function createDenoHost(opts: DenoHostOptions = {}): HostContext {
     importModule: (p) => {
       const href =
         pathToFileURL(abs(p)).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
-      return import(href) as Promise<Record<string, unknown>>;
+      const mod: Promise<Record<string, unknown>> = import(href);
+      return mod;
     },
     async serveHttp(port, handler) {
       return startDenoServer(port, handler);
@@ -124,12 +143,13 @@ function wrapSqlite(db: DatabaseSync): SqliteDb {
     exec: (sql) => db.exec(sql),
     run: (sql, params = []) => {
       const stmt = db.prepare(sql);
-      const r = stmt.run(...(params as never[]));
+      const r = stmt.run(...sqliteParams(params));
       return { changes: Number(r.changes), lastInsertRowid: r.lastInsertRowid };
     },
     all: <T>(sql: string, params: unknown[] = []) => {
       const stmt = db.prepare(sql);
-      return stmt.all(...(params as never[])) as T[];
+      // biome-ignore lint/plugin: Deno sqlite returns untyped row objects; SqliteDb.all<T> is the host adapter boundary.
+      return stmt.all(...sqliteParams(params)) as T[];
     },
     close: () => db.close(),
   };

package/src/runtime/adapters/detect.ts

@@ -4,11 +4,11 @@
 import type { HostContext } from "../core/host.ts";
 import { createNodeHost } from "./node.ts";
 import { createDenoHost } from "./deno.ts";
+import { denoGlobal } from "./globals.ts";
 
 /** True when running under Deno. */
 export function isDeno(): boolean {
-  const g = globalThis as { Deno?: { version?: unknown } };
-  return typeof g.Deno !== "undefined" && typeof g.Deno.version !== "undefined";
+  return denoGlobal()?.version !== undefined;
 }
 
 export interface SelectHostOptions {

package/src/runtime/adapters/globals.ts

@@ -0,0 +1,27 @@
+import { isRecord } from "../core/guards.ts";
+
+export interface DenoRuntimeGlobal {
+  version?: unknown;
+  stdin?: { readable?: ReadableStream<Uint8Array> };
+  args?: string[];
+  exit?: (code: number) => void;
+  addSignalListener?: (sig: string, cb: () => void) => void;
+}
+
+export interface ProcessRuntimeGlobal {
+  argv?: string[];
+  exit?: (code: number) => void;
+  stdin?: AsyncIterable<Uint8Array | string> & { setEncoding?(encoding: string): void };
+  on?: (sig: string, cb: () => void) => void;
+}
+
+export function denoGlobal(): DenoRuntimeGlobal | undefined {
+  const value: unknown = Reflect.get(globalThis, "Deno");
+  return isRecord(value) ? value : undefined;
+}
+
+export function processGlobal(): ProcessRuntimeGlobal | undefined {
+  const value: unknown = Reflect.get(globalThis, "process");
+  return isRecord(value) ? value : undefined;
+}
+

package/src/runtime/adapters/node.ts

@@ -18,6 +18,24 @@ import type {
   WatchHandle,
 } from "../core/host.ts";
 
+type SqliteParam = string | number | bigint | Uint8Array | null;
+
+function sqliteParams(params: unknown[]): SqliteParam[] {
+  return params.map((param) => {
+    if (
+      param === null ||
+      typeof param === "string" ||
+      typeof param === "number" ||
+      typeof param === "bigint" ||
+      param instanceof Uint8Array
+    ) {
+      return param;
+    }
+    if (typeof param === "boolean") return param ? 1 : 0;
+    throw new TypeError(`unsupported SQLite parameter type: ${typeof param}`);
+  });
+}
+
 export interface NodeHostOptions {
   /** Base directory relative paths resolve against. Default process.cwd(). */
   cwd?: string;
@@ -120,7 +138,8 @@ export function createNodeHost(opts: NodeHostOptions = {}): HostContext {
     importModule: (p) => {
       const href =
         pathToFileURL(abs(p)).href + (opts.importNonce ? `?v=${opts.importNonce}` : "");
-      return import(href) as Promise<Record<string, unknown>>;
+      const mod: Promise<Record<string, unknown>> = import(href);
+      return mod;
     },
     async importConnectorModule(entry) {
       ensureConnectorHooks();
@@ -166,12 +185,13 @@ function wrapNodeSqlite(db: DatabaseSync): SqliteDb {
     exec: (sql) => db.exec(sql),
     run: (sql, params = []) => {
       const stmt = db.prepare(sql);
-      const r = stmt.run(...(params as never[]));
+      const r = stmt.run(...sqliteParams(params));
       return { changes: Number(r.changes), lastInsertRowid: r.lastInsertRowid };
     },
     all: <T>(sql: string, params: unknown[] = []) => {
       const stmt = db.prepare(sql);
-      return stmt.all(...(params as never[])) as T[];
+      // biome-ignore lint/plugin: Node sqlite returns untyped row objects; SqliteDb.all<T> is the host adapter boundary.
+      return stmt.all(...sqliteParams(params)) as T[];
     },
     close: () => db.close(),
   };
@@ -180,7 +200,10 @@ function wrapNodeSqlite(db: DatabaseSync): SqliteDb {
 async function startNodeServer(port: number, handler: HttpHandler): Promise<HttpServer> {
   const server = createServer(async (nreq, nres) => {
     const chunks: Buffer[] = [];
-    for await (const c of nreq) chunks.push(c as Buffer);
+    for await (const c of nreq) {
+      if (Buffer.isBuffer(c)) chunks.push(c);
+      else chunks.push(Buffer.from(c));
+    }
     const bodyText = Buffer.concat(chunks).toString("utf8");
     const url = new URL(nreq.url ?? "/", "http://localhost");
     const headers = new Headers();

package/src/runtime/connector-worker-sdk.test.ts

@@ -22,8 +22,9 @@ test("defineWorker records handlers that drainDefinedWorkers returns then clears
 
 test("defineWorker rejects a missing type or non-function handle", () => {
   assert.throws(() => defineWorker({ type: "", handle: async () => ({}) }), /type` is required/);
+  const missingHandle: Parameters<typeof defineWorker>[0] = JSON.parse('{"type":"x"}');
   assert.throws(
-    () => defineWorker({ type: "x" } as unknown as Parameters<typeof defineWorker>[0]),
+    () => defineWorker(missingHandle),
     /handle must be a function/,
   );
   // A failed defineWorker must not leave a partial registration behind.

package/src/runtime/core/context.ts

@@ -1,6 +1,7 @@
 import type { AppManifest } from "./manifest.ts";
 import type { EngineClient, HostContext } from "./host.ts";
 import type { EngineSdkClient } from "../engine/sdk.ts";
+import type { TemplateSource } from "./modules/templates.ts";
 
 /** Everything a runtime module needs. Passed to each module's mount function. */
 export interface RuntimeContext {
@@ -9,6 +10,9 @@ export interface RuntimeContext {
   engine: EngineClient;
   /** App root directory (paths in the manifest are relative to this). */
   root: string;
+  /** Programmatic `{{name}}` template source for deploy-time substitution (globs or a
+   *  `name → content` map), merged over the manifest's `models.templates`. See `deployModels`. */
+  templates?: TemplateSource;
 }
 
 /** A mounted module returns a disposer so the runtime can tear it down cleanly. */

package/src/runtime/core/guards.ts

@@ -0,0 +1,10 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (isRecord(error) && typeof error.message === "string") return error.message;
+  return String(error);
+}
+

package/src/runtime/core/host.ts

@@ -132,11 +132,11 @@ export class BpmnError extends Error {
  *  BpmnError constructed against a different copy of this module still routes as
  *  a BPMN error rather than a generic failure). */
 export function isBpmnError(err: unknown): err is { errorCode: string; message?: string } {
+  if (typeof err !== "object" || err === null) return false;
+  const errorCode = "errorCode" in err ? err.errorCode : undefined;
   return (
-    typeof err === "object" &&
-    err !== null &&
-    typeof (err as { errorCode?: unknown }).errorCode === "string" &&
-    (err as { errorCode: string }).errorCode.length > 0
+    typeof errorCode === "string" &&
+    errorCode.length > 0
   );
 }
 

package/src/runtime/core/manifest.ts

@@ -32,6 +32,19 @@ export type {
   Worker,
 } from "@nanobpm/nano-app-schema";
 
+// The published `@nanobpm/nano-app-schema` does not yet declare `models.templates`; the manifest
+// validator only enforces `additionalProperties:false` at the top level (see validate.ts), so the
+// nested key is accepted at runtime. Augment `Models` here so the deploy path can read it typed
+// (no cast) until it is formalized in the schema package.
+declare module "@nanobpm/nano-app-schema" {
+  interface Models {
+    /** `{{name}}` template sources substituted into model resources at deploy time: globs, a bare
+     *  directory (scanned), or literal files. A template's name is its file stem
+     *  (`prompts/review-round.md` → `{{review-round}}`). See `deployModels`. */
+    templates?: string[];
+  }
+}
+
 /** The job type a worker subscribes to (schema key: `taskType`). */
 export function workerJobType(w: Worker): string | undefined {
   return w.taskType;
@@ -52,13 +65,14 @@ export function expandEnvString(input: string, lookup: (name: string) => string
 }
 
 /** Recursively expand env placeholders across every string in a JSON-ish value. */
-export function expandEnv<T>(value: T, lookup: (name: string) => string | undefined): T {
-  if (typeof value === "string") return expandEnvString(value, lookup) as unknown as T;
-  if (Array.isArray(value)) return value.map((v) => expandEnv(v, lookup)) as unknown as T;
+export function expandEnv<T>(value: T, lookup: (name: string) => string | undefined): T;
+export function expandEnv(value: unknown, lookup: (name: string) => string | undefined): unknown {
+  if (typeof value === "string") return expandEnvString(value, lookup);
+  if (Array.isArray(value)) return value.map((v) => expandEnv(v, lookup));
   if (value && typeof value === "object") {
     const out: Record<string, unknown> = {};
     for (const [k, v] of Object.entries(value)) out[k] = expandEnv(v, lookup);
-    return out as T;
+    return out;
   }
   return value;
 }
@@ -68,7 +82,7 @@ export function parseManifest(
   json: string,
   lookup: (name: string) => string | undefined = () => undefined,
 ): AppManifest {
-  const raw = JSON.parse(json) as AppManifest;
+  const raw: AppManifest = JSON.parse(json);
   return expandEnv(raw, lookup);
 }
 

package/src/runtime/core/modules/actions.test.ts

@@ -1,9 +1,10 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import type { AppApi, RuntimeContext } from "../context.ts";
-import type { HttpRequest } from "../host.ts";
+import type { EngineClient, HostContext, HttpRequest } from "../host.ts";
 import { makeRouter } from "../router.ts";
 import { mountActions, resolveActionHandler, type ActionHandler } from "./actions.ts";
+import { DataLayer } from "./datasource.ts";
 
 function req(method: string, path: string, opts: { query?: string; body?: string } = {}): HttpRequest {
   return {
@@ -21,28 +22,68 @@ interface Built {
   logs: Array<{ level: string; msg: string }>;
 }
 
+const engine: EngineClient = {
+  deployResources: async () => ({ deployed: 0 }),
+  createInstance: async () => ({ processInstanceKey: "pi" }),
+  cancelInstance: async () => {},
+  publishMessage: async () => {},
+  searchUserTasks: async () => [],
+  completeUserTask: async () => {},
+  registerWorker: async (jobType) => ({ jobType, unsubscribe: async () => {} }),
+  close: async () => {},
+};
+
+const data = new DataLayer(new Map(), undefined, {});
+
+function appFixture(over: Partial<AppApi> = {}): AppApi {
+  return {
+    manifest: { schemaVersion: 1, id: "t", name: "T" },
+    data,
+    engine,
+    env: () => undefined,
+    log: () => {},
+    ...over,
+  };
+}
+
+function route(router: ReturnType<typeof makeRouter>): Built["router"] {
+  return async (r) => router(r);
+}
+
 function build(
   actions: RuntimeContext["manifest"]["actions"],
   modules: Record<string, Record<string, unknown>>,
-  app: AppApi = {} as AppApi,
+  app: AppApi = appFixture(),
 ): Built {
   const imported: string[] = [];
   const logs: Array<{ level: string; msg: string }> = [];
-  const ctx = {
-    root: "/app",
-    manifest: { schemaVersion: 1, id: "t", name: "T", actions } as RuntimeContext["manifest"],
-    host: {
-      importModule: (path: string) => {
-        imported.push(path);
-        const mod = modules[path];
-        if (!mod) return Promise.reject(new Error(`no module at ${path}`));
-        return Promise.resolve(mod);
-      },
-      log: (level: string, msg: string) => logs.push({ level, msg }),
+  const host: HostContext = {
+    runtime: "node",
+    env: () => undefined,
+    readTextFile: async () => "",
+    listDir: async () => [],
+    exists: async () => false,
+    openSqlite: () => {
+      throw new Error("sqlite not used in this test");
     },
-  } as unknown as RuntimeContext;
+    importModule: (path: string) => {
+      imported.push(path);
+      const mod = modules[path];
+      if (!mod) return Promise.reject(new Error(`no module at ${path}`));
+      return Promise.resolve(mod);
+    },
+    serveHttp: async () => ({ port: 0, stop: async () => {} }),
+    now: () => 0,
+    log: (level: string, msg: string) => logs.push({ level, msg }),
+  };
+  const ctx: RuntimeContext = {
+    root: "/app",
+    manifest: { schemaVersion: 1, id: "t", name: "T", actions },
+    engine,
+    host,
+  };
   const handle = mountActions(ctx, app);
-  const router = makeRouter(handle.routes) as unknown as Built["router"];
+  const router = route(makeRouter(handle.routes));
   return { router, imported, logs };
 }
 
@@ -56,7 +97,7 @@ test("resolveActionHandler prefers default, then handler", () => {
 
 test("routes an action to its handler with parsed body + injected app", async () => {
   const seen: unknown[] = [];
-  const app = { id: "myApp" } as unknown as AppApi;
+  const app = appFixture({ manifest: { schemaVersion: 1, id: "myApp", name: "My App" } });
   const handler: ActionHandler = (input, a) => {
     seen.push({ body: input.body, method: input.req.method, app: a });
     return { status: 201, body: { ok: true } };
@@ -177,7 +218,7 @@ test("an absolute module path is used as-is (not joined to root)", async () => {
 
 test("declarations missing path or module are skipped with a warning", () => {
   const { router, logs } = build(
-    [{ path: "/a" } as unknown as { path: string; module: string }],
+    JSON.parse('[{"path":"/a"}]'),
     {},
   );
   void router;
@@ -196,22 +237,32 @@ test("a manifest path without a leading slash is normalized to match", async ()
 test("a rejected import is evicted from the cache so a later load can succeed", async () => {
   let attempt = 0;
   const imported: string[] = [];
-  const ctx = {
+  const host: HostContext = {
+    runtime: "node",
+    env: () => undefined,
+    readTextFile: async () => "",
+    listDir: async () => [],
+    exists: async () => false,
+    openSqlite: () => {
+      throw new Error("sqlite not used in this test");
+    },
+    importModule: (path: string) => {
+      imported.push(path);
+      attempt += 1;
+      if (attempt === 1) return Promise.reject(new Error("transient"));
+      return Promise.resolve({ default: () => ({ body: "ok" }) });
+    },
+    serveHttp: async () => ({ port: 0, stop: async () => {} }),
+    now: () => 0,
+    log: () => {},
+  };
+  const ctx: RuntimeContext = {
     root: "/app",
     manifest: { schemaVersion: 1, id: "t", name: "T", actions: [{ path: "/a", module: "m.ts" }] },
-    host: {
-      importModule: (path: string) => {
-        imported.push(path);
-        attempt += 1;
-        if (attempt === 1) return Promise.reject(new Error("transient"));
-        return Promise.resolve({ default: () => ({ body: "ok" }) });
-      },
-      log: () => {},
-    },
-  } as unknown as import("../context.ts").RuntimeContext;
-  const router = makeRouter(mountActions(ctx, {} as import("../context.ts").AppApi).routes) as unknown as (
-    r: HttpRequest,
-  ) => Promise<{ status?: number; body?: string }>;
+    engine,
+    host,
+  };
+  const router = route(makeRouter(mountActions(ctx, appFixture()).routes));
   const first = await router(req("POST", "/a", { body: "{}" }));
   assert.equal(first.status, 500); // transient failure surfaces
   const second = await router(req("POST", "/a", { body: "{}" }));

package/src/runtime/core/modules/actions.ts

@@ -11,8 +11,8 @@
 // while an unmatched process still falls through to the generic `/app/actions/start/` route.
 
 import type { AppApi, RuntimeContext } from "../context.ts";
+import { errorMessage } from "../guards.ts";
 import type { HttpRequest } from "../host.ts";
-import type { ActionDecl } from "../manifest.ts";
 import { json, normalizeRoutePath, type Route } from "../router.ts";
 
 /** The request handed to an action handler: the raw request plus its parsed JSON body. */
@@ -46,14 +46,18 @@ export type ActionHandler = (
   app: AppApi,
 ) => Promise<ActionResult | void> | ActionResult | void;
 
+function isActionHandler(value: unknown): value is ActionHandler {
+  return typeof value === "function";
+}
+
 /**
  * Resolve an action handler from a loaded module, in priority order:
  *   1. `default` (when it is a function — the common one-handler-per-file case)
  *   2. a named export `handler`
  */
 export function resolveActionHandler(mod: Record<string, unknown>): ActionHandler | undefined {
-  if (typeof mod.default === "function") return mod.default as ActionHandler;
-  if (typeof mod.handler === "function") return mod.handler as ActionHandler;
+  if (isActionHandler(mod.default)) return mod.default;
+  if (isActionHandler(mod.handler)) return mod.handler;
   return undefined;
 }
 
@@ -69,7 +73,7 @@ export interface ActionsHandle {
  * surfaces as a clear `500` on that route rather than failing the whole boot.
  */
 export function mountActions(ctx: RuntimeContext, app: AppApi): ActionsHandle {
-  const decls = (ctx.manifest.actions ?? []) as ActionDecl[];
+  const decls = ctx.manifest.actions ?? [];
   const routes: Route[] = [];
   const mounted: Array<{ path: string; method: string; module: string; prefix: boolean }> = [];
 
@@ -96,7 +100,7 @@ export function mountActions(ctx: RuntimeContext, app: AppApi): ActionsHandle {
   for (const decl of decls) {
     if (!decl?.path || !decl?.module) {
       ctx.host.log("warn", "skipping action: needs both `path` and `module`", {
-        action: decl as unknown as Record<string, unknown>,
+        action: decl,
       });
       continue;
     }
@@ -130,7 +134,7 @@ export function mountActions(ctx: RuntimeContext, app: AppApi): ActionsHandle {
           ctx.host.log("error", "action handler module failed to load", {
             path,
             module: decl.module,
-            error: String((e as Error)?.message ?? e),
+            error: errorMessage(e),
           });
           return json({ error: `action handler ${decl.module} failed to load` }, 500);
         }
@@ -150,7 +154,7 @@ export function mountActions(ctx: RuntimeContext, app: AppApi): ActionsHandle {
             body: result.body === undefined ? undefined : JSON.stringify(result.body),
           };
         } catch (e) {
-          return json({ error: String((e as Error)?.message ?? e) }, 500);
+          return json({ error: errorMessage(e) }, 500);
         }
       },
     });

package/src/runtime/core/modules/connectors.test.ts

@@ -1,15 +1,22 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import type { AppApi, RuntimeContext } from "../context.ts";
-import type { EngineJob, JobHandler, WorkerSubscription } from "../host.ts";
+import type { EngineClient, EngineJob, HostContext, JobHandler, WorkerSubscription } from "../host.ts";
 import { BpmnError } from "../host.ts";
 import type { AppManifest } from "../manifest.ts";
 import { defineWorker } from "../../connector-worker-sdk.ts";
 import { adaptConnectorHandler, mountConnectors, resolveInstalledConnectors } from "./connectors.ts";
+import { DataLayer } from "./datasource.ts";
 
 /** A tiny engine that records registrations and can deliver a job to a handler. */
-class MiniEngine {
+class MiniEngine implements EngineClient {
   workers = new Map<string, JobHandler>();
+  async deployResources(): Promise<{ deployed: number }> { return { deployed: 0 }; }
+  async createInstance(): Promise<{ processInstanceKey: string }> { return { processInstanceKey: "pi" }; }
+  async cancelInstance(): Promise<void> {}
+  async publishMessage(): Promise<void> {}
+  async searchUserTasks(): Promise<[]> { return []; }
+  async completeUserTask(): Promise<void> {}
   async registerWorker(jobType: string, handler: JobHandler): Promise<WorkerSubscription> {
     this.workers.set(jobType, handler);
     return { jobType, unsubscribe: async () => void this.workers.delete(jobType) };
@@ -19,6 +26,7 @@ class MiniEngine {
     if (!h) throw new Error(`no worker for ${jobType}`);
     return h(job);
   }
+  async close(): Promise<void> {}
 }
 
 interface FakeHostOptions {
@@ -37,32 +45,45 @@ function makeCtx(
 ): { ctx: RuntimeContext; logs: Array<{ level: string; msg: string }> } {
   const logs: Array<{ level: string; msg: string }> = [];
   const files = opts.files ?? {};
-  const host: Record<string, unknown> = {
+  const host: HostContext = {
     runtime: "node",
+    env: (name) => opts.env?.[name],
     log: (level: string, msg: string) => logs.push({ level, msg }),
     exists: async (p: string) => p in files,
     readTextFile: async (p: string) => {
       if (!(p in files)) throw new Error(`ENOENT ${p}`);
       return files[p];
     },
+    listDir: async () => [],
+    openSqlite: () => {
+      throw new Error("sqlite not used in this test");
+    },
     importModule: () => Promise.reject(new Error("no modules in this test")),
+    serveHttp: async () => ({ port: 0, stop: async () => {} }),
+    now: () => 0,
   };
   if (!opts.noConnectorHost) {
     host.importConnectorModule = async (entry: string) => {
       opts.onImport?.(entry);
     };
   }
-  const ctx = {
+  const ctx: RuntimeContext = {
     root: "/app",
-    manifest: { schemaVersion: 1, id: "t", name: "T", ...manifest } as AppManifest,
-    engine: engine as unknown as RuntimeContext["engine"],
+    manifest: { schemaVersion: 1, id: "t", name: "T", ...manifest },
+    engine,
     host,
-  } as unknown as RuntimeContext;
+  };
   return { ctx, logs };
 }
 
 function makeApp(env: Record<string, string> = {}): AppApi {
-  return { env: (n: string) => env[n], log: () => {} } as unknown as AppApi;
+  return {
+    manifest: { schemaVersion: 1, id: "t", name: "T" },
+    data: new DataLayer(new Map(), undefined, {}),
+    engine: new MiniEngine(),
+    env: (n: string) => env[n],
+    log: () => {},
+  };
 }
 
 const PKG = "@nanobpm/nano-ide-connector-slack";

package/src/runtime/core/modules/connectors.ts

@@ -16,6 +16,7 @@
 // the pack's `@nanobpm/worker` import live behind `host.importConnectorModule`.
 
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
+import { errorMessage, isRecord } from "../guards.ts";
 import { BpmnError, type EngineJob, type JobHandler, type WorkerSubscription } from "../host.ts";
 import { workerJobType, type Worker } from "../manifest.ts";
 import {
@@ -85,10 +86,11 @@ async function readJson<T>(
   const path = joinRoot(ctx.root, relPath);
   if (!(await ctx.host.exists(path))) return undefined;
   try {
-    return JSON.parse(await ctx.host.readTextFile(path)) as T;
+    const parsed: T = JSON.parse(await ctx.host.readTextFile(path));
+    return parsed;
   } catch (err) {
     if (opts?.strict) {
-      throw new Error(`failed to parse ${relPath}: ${(err as Error).message}`);
+      throw new Error(`failed to parse ${relPath}: ${errorMessage(err)}`);
     }
     return undefined;
   }
@@ -157,7 +159,7 @@ export function adaptConnectorHandler(worker: DefinedConnectorWorker): JobHandle
     if (outcome?.kind === "fail") throw new Error(outcome.message);
     if (outcome?.kind === "complete") return outcome.vars ?? {};
     // No explicit outcome: fall back to the handle's return value (SDK-style).
-    return ret && typeof ret === "object" ? (ret as Record<string, unknown>) : {};
+    return isRecord(ret) ? ret : {};
   };
 }
 
@@ -169,7 +171,7 @@ export function adaptConnectorHandler(worker: DefinedConnectorWorker): JobHandle
  * the host cannot host connector workers (`importConnectorModule` absent).
  */
 export async function mountConnectors(ctx: RuntimeContext, app: AppApi): Promise<ConnectorsHandle> {
-  const decls = (ctx.manifest.workers ?? []).filter((w) => (w as Worker).connector) as Worker[];
+  const decls: Worker[] = (ctx.manifest.workers ?? []).filter((w) => Boolean(w.connector));
   const subs: WorkerSubscription[] = [];
   const jobTypes: string[] = [];
   if (decls.length === 0) return makeHandle(subs, jobTypes);