@nanobpm/urban 0.16.1 → 0.17.0

package/dist/runtime/core/manifest.d.ts

@@ -1,138 +1,8 @@
 import type { HostContext } from "./host.ts";
-export interface DataSource {
-    driver: string;
-    url: string;
-    migrations?: string;
-}
-export interface TypeField {
-    type: string;
-    optional?: boolean;
-}
-export interface DomainType {
-    name?: string;
-    table?: string;
-    fields?: Record<string, TypeField>;
-}
-export interface WorkerDecl {
-    /** Job/task type the worker subscribes to. Schema allows `taskType` or `type`. */
-    taskType?: string;
-    type?: string;
-    /** Path to the handler module, relative to the app root. Mutually exclusive with `llm`. */
-    handler?: string;
-    /** Name of an `llm[]` binding used as the worker (LLM-as-worker). Mutually exclusive with `handler`. */
-    llm?: string;
-}
-/**
- * One named LLM binding (`llm.<id>` in the manifest). A binding is usable as a worker
- * (LLM-as-worker, ADR 0022 §E role 1) or as a chat surface agent. `provider` selects how
- * the endpoint is resolved (`"env"` reads it from the environment); `model` is typically
- * an env template. When `output.decision` is set, the model's JSON reply is fed through
- * that DMN decision (the "rails") and the decision's output is returned instead.
- */
-export interface LlmBinding {
-    /** Provider selector. `"env"` resolves an OpenAI-compatible endpoint from the environment. */
-    provider: string;
-    /** Model id, typically an env template (e.g. `${NANO_APP_LLM_MODEL}`). */
-    model: string;
-    /** Constrains the model's structured output — currently a DMN decision id (the rails). */
-    output?: {
-        decision?: string;
-    };
-    /** Action-API tools the agent may call (chat-agent role; unused by the worker role). */
-    tools?: string[];
-}
-export interface TriggerDecl {
-    id: string;
-    type: string;
-    path?: string;
-    auth?: string;
-    /** cron: the 5-field crontab spec (UTC), e.g. "0 6 * * *". */
-    spec?: string;
-    /** cron catch-up policy for fires missed while the app was down. Default "skip". */
-    onMissed?: "skip" | "once" | "all";
-    /** Source-kind-specific settings (e.g. file `{ pollMs }`). */
-    config?: Record<string, unknown>;
-    /** Name of a connections[] entry supplying this source's credentials. */
-    connection?: string;
-    /** Maps the event to one engine call: start a process OR publish a message (ADR 0025 §1). */
-    action?: {
-        /** Process id/name to start. */
-        start?: string;
-        /** messageName to publish as a CorrelateMessage. */
-        message?: string;
-        /** correlationKey (literal, or `= body.path`) for a message action. */
-        correlationKey?: string;
-        /**
-         * Variables for the started instance / published message. Per the manifest schema
-         * (`#/$defs/triggerAction.variables`) this is a FEEL string over the event body
-         * (e.g. `= body.payload`); an inline object literal is also accepted for convenience.
-         */
-        variables?: string | Record<string, unknown>;
-    };
-}
-export interface SurfaceDecl {
-    enabled?: boolean;
-    path?: string;
-    agent?: string;
-    /** pages surface: directory of `*.page.json` (relative to app root). Default `pages`. */
-    pagesDir?: string;
-    /** pages surface: the page served at `/`. Default `home`. */
-    homePage?: string;
-    /** pages surface: max rows a `dataGrid` fetch returns. Default 200. */
-    rowLimit?: number;
-    /** pages surface: the injected default datasource name. Default `app`. */
-    sourceName?: string;
-}
-/**
- * An app-authored action handler override (ADR 0055 phase 3). Each declaration binds a
- * route to a handler module (default-exports an `ActionHandler`), letting an app wrap the
- * generic pages start/cancel/message actions with business logic. Mounted before the
- * generic pages action routes, so an exact override shadows the generic one.
- */
-export interface ActionDecl {
-    /** Route path to serve, e.g. "/app/actions/cancel" or "/app/actions/start/convergence-loop". */
-    path: string;
-    /** Handler module path relative to the app root; default-exports an `ActionHandler`. */
-    module: string;
-    /** HTTP method to match. Default "POST". */
-    method?: string;
-    /** Match `path` as a prefix rather than exactly. Default false. */
-    prefix?: boolean;
-}
-export interface AppManifest {
-    $schema?: string;
-    schemaVersion: 1;
-    id: string;
-    name: string;
-    codename?: string;
-    runtime?: {
-        engine?: string;
-        node?: string;
-    };
-    models?: {
-        processes?: string[];
-        decisions?: string[];
-        forms?: string[];
-    };
-    data?: {
-        default?: string;
-        sources?: Record<string, DataSource>;
-    };
-    types?: Record<string, DomainType>;
-    triggers?: TriggerDecl[];
-    connections?: Record<string, {
-        type: string;
-        [k: string]: unknown;
-    }>;
-    surfaces?: Record<string, SurfaceDecl>;
-    actions?: ActionDecl[];
-    workers?: WorkerDecl[];
-    llm?: Record<string, LlmBinding>;
-    security?: Record<string, unknown>;
-    [k: string]: unknown;
-}
-/** The normalised job type for a worker declaration (`taskType` preferred, `type` fallback). */
-export declare function workerJobType(w: WorkerDecl): string | undefined;
+import type { AppManifest, Worker } from "@nanobpm/nano-app-schema";
+export type { ActionDecl, AppManifest, ChatSurface, Connection, Data, DataSource, DomainField, DomainType, LlmBinding, Models, PagesSurface, Runtime, Security, Surfaces, TaskInboxSurface, Trigger, TriggerAction, Worker, } from "@nanobpm/nano-app-schema";
+/** The job type a worker subscribes to (schema key: `taskType`). */
+export declare function workerJobType(w: Worker): string | undefined;
 /**
  * Expand `${VAR}` and `${VAR:-default}` placeholders in a string using `lookup`.
  * Unset vars with no default expand to "" (matching common shell semantics).

package/dist/runtime/core/manifest.js

@@ -1,10 +1,15 @@
-// Manifest types (a hand-mirrored subset of nano-app.schema.json — the block shapes the
-// runtime actually consumes) plus env-placeholder expansion and a host-driven loader.
-// The schema itself (src/schema/nano-app.schema.json) remains the source of truth for
-// validation; see validate.ts.
-/** The normalised job type for a worker declaration (`taskType` preferred, `type` fallback). */
+// Manifest types + env-placeholder expansion + a host-driven loader.
+//
+// The App manifest contract (nano.app.json) is owned by the canonical
+// @nanobpm/nano-app-schema package (ADR 0027): the JSON Schema and its generated
+// TypeScript types are the single source of truth. This module re-exports those
+// types (type-only, so nothing from the package is pulled into the runtime
+// bundle) and adds the runtime-side helpers the App loader needs. No shape is
+// hand-mirrored here — that eliminated the schema/type drift the vendored copies
+// used to cause.
+/** The job type a worker subscribes to (schema key: `taskType`). */
 export function workerJobType(w) {
-    return w.taskType ?? w.type;
+    return w.taskType;
 }
 const ENV_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
 /**

package/dist/runtime/core/modules/triggers.d.ts

@@ -1,6 +1,5 @@
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
 import { type Route } from "../router.ts";
-import type { TriggerDecl } from "../manifest.ts";
 export interface TriggersHandle extends Mounted {
     routes: Route[];
 }
@@ -38,7 +37,20 @@ export declare function resolveActionVariables(expr: unknown, scope: Scope): Rec
  * of `correlationKey`/`variables`; cron passes a minimal `{ firedAt }` body. Returns what
  * was done.
  */
-export declare function runTriggerAction(app: AppApi, action: TriggerDecl["action"], scope: Scope): Promise<{
+/**
+ * The trigger action as the *runtime* helper reads it: the fields `runTriggerAction`
+ * consumes, with `variables` permitting an inline object literal as well as a FEEL string.
+ * The manifest surface keeps `variables` string-only (a FEEL expression);
+ * `resolveActionVariables` tolerates both, so this shape matches runtime behaviour without
+ * loosening the schema. A locked `Trigger["action"]` is assignable to it.
+ */
+export interface RuntimeTriggerAction {
+    start?: string;
+    message?: string;
+    correlationKey?: string;
+    variables?: string | Record<string, unknown>;
+}
+export declare function runTriggerAction(app: AppApi, action: RuntimeTriggerAction | undefined, scope: Scope): Promise<{
     kind: "start" | "message" | "none";
     target?: string;
     correlationKey?: string;

package/dist/runtime/core/modules/triggers.js

@@ -75,12 +75,6 @@ function headerRecord(req) {
     req.headers.forEach((v, k) => (out[k.toLowerCase()] = v));
     return out;
 }
-/**
- * Fire a trigger's action against the engine: start a process or publish a message
- * (ADR 0025 §1). `scope` supplies the event body/headers/query for FEEL-ish resolution
- * of `correlationKey`/`variables`; cron passes a minimal `{ firedAt }` body. Returns what
- * was done.
- */
 export async function runTriggerAction(app, action, scope) {
     if (!action)
         return { kind: "none" };

package/dist/runtime/core/validate.js

@@ -1,12 +1,13 @@
-// Manifest validation. We deliberately avoid a heavyweight JSON-Schema engine here to
-// keep core dependency-free and runtime-agnostic. Instead we drive validation *from* the
-// vendored nano-app.schema.json (the ADR 0027 source of truth) for the top-level envelope
-// — required keys, allowed keys (additionalProperties:false), the schemaVersion const, and
-// the id slug pattern — and then layer the runtime's binding rules (a worker needs a
-// handler, a data source needs driver+url, a typed table needs fields, a trigger needs
-// id+type). Reading the schema means the envelope check tracks the schema and can't drift
-// from it silently.
-import schema from "../schema/nano-app.schema.json" with { type: "json" };
+// Manifest validation. We deliberately avoid a heavyweight JSON-Schema engine here to keep
+// core lean and runtime-agnostic. Instead we drive validation *from* the canonical
+// nano-app.schema.json (the ADR 0027 source of truth, imported from the
+// @nanobpm/nano-app-schema package) for the top-level envelope — required keys, allowed keys
+// (additionalProperties:false), the schemaVersion const, and the id slug pattern — and then
+// layer the runtime's binding rules (a worker needs a handler, a data source needs
+// driver+url, a typed table needs fields, a trigger needs id+type). Importing the shared
+// schema JSON means the envelope check tracks the published schema and can't drift from it
+// silently — the whole point of consuming the package rather than vendoring a copy.
+import schema from "@nanobpm/nano-app-schema/schema" with { type: "json" };
 import { workerJobType } from "./manifest.js";
 export class ManifestValidationError extends Error {
     issues;
@@ -53,7 +54,7 @@ export function collectManifestIssues(m) {
     if (Array.isArray(man.workers)) {
         man.workers.forEach((w, i) => {
             if (!workerJobType(w)) {
-                issues.push({ path: `workers[${i}]`, message: "missing taskType/type" });
+                issues.push({ path: `workers[${i}]`, message: "missing taskType" });
             }
             // The schema allows a worker backed by either a `handler` file or an `llm`
             // binding (oneOf). Require exactly one — don't force `handler`.

package/dist/runtime/index.d.ts

@@ -1,7 +1,7 @@
 export { createUrbanApp } from "./core/runtime.ts";
 export type { CreateUrbanAppOptions, MountFlags, UrbanApp, } from "./core/runtime.ts";
 export { expandEnv, expandEnvString, loadManifest, parseManifest, workerJobType, } from "./core/manifest.ts";
-export type { ActionDecl, AppManifest, DataSource, DomainType, LlmBinding, SurfaceDecl, TriggerDecl, TypeField, WorkerDecl, } from "./core/manifest.ts";
+export type { ActionDecl, AppManifest, ChatSurface, DataSource, DomainField, DomainType, LlmBinding, PagesSurface, Surfaces, TaskInboxSurface, Trigger, Worker, } from "./core/manifest.ts";
 export { collectManifestIssues, ManifestValidationError, validateManifest, } from "./core/validate.ts";
 export type { ValidationIssue } from "./core/validate.ts";
 export type { EngineClient, EngineJob, HostContext, HttpHandler, HttpRequest, HttpResponse, HttpServer, JobHandler, SqliteDb, WatchHandle, WorkerSubscription, } from "./core/host.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
   "license": "Apache-2.0",
   "type": "module",
@@ -55,13 +55,14 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node -e \"const fs=require('fs');fs.mkdirSync('dist/runtime/schema',{recursive:true});fs.copyFileSync('src/runtime/schema/nano-app.schema.json','dist/runtime/schema/nano-app.schema.json')\"",
+    "build": "tsc -p tsconfig.build.json",
     "prepack": "npm run build",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "node --test --experimental-strip-types \"src/**/*.test.ts\"",
     "test:deno": "deno test -A --no-check src/"
   },
   "dependencies": {
+    "@nanobpm/nano-app-schema": "^0.1.0",
     "@nanobpm/nano-sdk": "^1.2.3",
     "@nanobpm/workflow": "^0.7.0",
     "bpmn-auto-layout": "^2.0.0-alpha.2",

package/src/runtime/core/manifest.test.ts

@@ -24,8 +24,7 @@ test("parseManifest expands env in place", () => {
   assert.equal(m.name, "App");
 });
 
-test("workerJobType prefers taskType then type", () => {
+test("workerJobType returns the taskType", () => {
   assert.equal(workerJobType({ taskType: "a", handler: "h" }), "a");
-  assert.equal(workerJobType({ type: "b", handler: "h" }), "b");
-  assert.equal(workerJobType({ handler: "h" }), undefined);
+  assert.equal(workerJobType({ taskType: "llm-job", llm: "gpt" }), "llm-job");
 });

package/src/runtime/core/manifest.ts

@@ -1,139 +1,40 @@
-// Manifest types (a hand-mirrored subset of nano-app.schema.json — the block shapes the
-// runtime actually consumes) plus env-placeholder expansion and a host-driven loader.
-// The schema itself (src/schema/nano-app.schema.json) remains the source of truth for
-// validation; see validate.ts.
+// Manifest types + env-placeholder expansion + a host-driven loader.
+//
+// The App manifest contract (nano.app.json) is owned by the canonical
+// @nanobpm/nano-app-schema package (ADR 0027): the JSON Schema and its generated
+// TypeScript types are the single source of truth. This module re-exports those
+// types (type-only, so nothing from the package is pulled into the runtime
+// bundle) and adds the runtime-side helpers the App loader needs. No shape is
+// hand-mirrored here — that eliminated the schema/type drift the vendored copies
+// used to cause.
 
 import type { HostContext } from "./host.ts";
-
-export interface DataSource {
-  driver: string;
-  url: string;
-  migrations?: string;
-}
-
-export interface TypeField {
-  type: string;
-  optional?: boolean;
-}
-
-export interface DomainType {
-  name?: string;
-  table?: string;
-  fields?: Record<string, TypeField>;
-}
-
-export interface WorkerDecl {
-  /** Job/task type the worker subscribes to. Schema allows `taskType` or `type`. */
-  taskType?: string;
-  type?: string;
-  /** Path to the handler module, relative to the app root. Mutually exclusive with `llm`. */
-  handler?: string;
-  /** Name of an `llm[]` binding used as the worker (LLM-as-worker). Mutually exclusive with `handler`. */
-  llm?: string;
-}
-
-/**
- * One named LLM binding (`llm.<id>` in the manifest). A binding is usable as a worker
- * (LLM-as-worker, ADR 0022 §E role 1) or as a chat surface agent. `provider` selects how
- * the endpoint is resolved (`"env"` reads it from the environment); `model` is typically
- * an env template. When `output.decision` is set, the model's JSON reply is fed through
- * that DMN decision (the "rails") and the decision's output is returned instead.
- */
-export interface LlmBinding {
-  /** Provider selector. `"env"` resolves an OpenAI-compatible endpoint from the environment. */
-  provider: string;
-  /** Model id, typically an env template (e.g. `${NANO_APP_LLM_MODEL}`). */
-  model: string;
-  /** Constrains the model's structured output — currently a DMN decision id (the rails). */
-  output?: { decision?: string };
-  /** Action-API tools the agent may call (chat-agent role; unused by the worker role). */
-  tools?: string[];
-}
-
-export interface TriggerDecl {
-  id: string;
-  type: string;
-  path?: string;
-  auth?: string;
-  /** cron: the 5-field crontab spec (UTC), e.g. "0 6 * * *". */
-  spec?: string;
-  /** cron catch-up policy for fires missed while the app was down. Default "skip". */
-  onMissed?: "skip" | "once" | "all";
-  /** Source-kind-specific settings (e.g. file `{ pollMs }`). */
-  config?: Record<string, unknown>;
-  /** Name of a connections[] entry supplying this source's credentials. */
-  connection?: string;
-  /** Maps the event to one engine call: start a process OR publish a message (ADR 0025 §1). */
-  action?: {
-    /** Process id/name to start. */
-    start?: string;
-    /** messageName to publish as a CorrelateMessage. */
-    message?: string;
-    /** correlationKey (literal, or `= body.path`) for a message action. */
-    correlationKey?: string;
-    /**
-     * Variables for the started instance / published message. Per the manifest schema
-     * (`#/$defs/triggerAction.variables`) this is a FEEL string over the event body
-     * (e.g. `= body.payload`); an inline object literal is also accepted for convenience.
-     */
-    variables?: string | Record<string, unknown>;
-  };
-}
-
-export interface SurfaceDecl {
-  enabled?: boolean;
-  path?: string;
-  agent?: string;
-  /** pages surface: directory of `*.page.json` (relative to app root). Default `pages`. */
-  pagesDir?: string;
-  /** pages surface: the page served at `/`. Default `home`. */
-  homePage?: string;
-  /** pages surface: max rows a `dataGrid` fetch returns. Default 200. */
-  rowLimit?: number;
-  /** pages surface: the injected default datasource name. Default `app`. */
-  sourceName?: string;
-}
-
-/**
- * An app-authored action handler override (ADR 0055 phase 3). Each declaration binds a
- * route to a handler module (default-exports an `ActionHandler`), letting an app wrap the
- * generic pages start/cancel/message actions with business logic. Mounted before the
- * generic pages action routes, so an exact override shadows the generic one.
- */
-export interface ActionDecl {
-  /** Route path to serve, e.g. "/app/actions/cancel" or "/app/actions/start/convergence-loop". */
-  path: string;
-  /** Handler module path relative to the app root; default-exports an `ActionHandler`. */
-  module: string;
-  /** HTTP method to match. Default "POST". */
-  method?: string;
-  /** Match `path` as a prefix rather than exactly. Default false. */
-  prefix?: boolean;
-}
-
-export interface AppManifest {
-  $schema?: string;
-  schemaVersion: 1;
-  id: string;
-  name: string;
-  codename?: string;
-  runtime?: { engine?: string; node?: string };
-  models?: { processes?: string[]; decisions?: string[]; forms?: string[] };
-  data?: { default?: string; sources?: Record<string, DataSource> };
-  types?: Record<string, DomainType>;
-  triggers?: TriggerDecl[];
-  connections?: Record<string, { type: string; [k: string]: unknown }>;
-  surfaces?: Record<string, SurfaceDecl>;
-  actions?: ActionDecl[];
-  workers?: WorkerDecl[];
-  llm?: Record<string, LlmBinding>;
-  security?: Record<string, unknown>;
-  [k: string]: unknown;
-}
-
-/** The normalised job type for a worker declaration (`taskType` preferred, `type` fallback). */
-export function workerJobType(w: WorkerDecl): string | undefined {
-  return w.taskType ?? w.type;
+import type { AppManifest, Worker } from "@nanobpm/nano-app-schema";
+
+export type {
+  ActionDecl,
+  AppManifest,
+  ChatSurface,
+  Connection,
+  Data,
+  DataSource,
+  DomainField,
+  DomainType,
+  LlmBinding,
+  Models,
+  PagesSurface,
+  Runtime,
+  Security,
+  Surfaces,
+  TaskInboxSurface,
+  Trigger,
+  TriggerAction,
+  Worker,
+} from "@nanobpm/nano-app-schema";
+
+/** The job type a worker subscribes to (schema key: `taskType`). */
+export function workerJobType(w: Worker): string | undefined {
+  return w.taskType;
 }
 
 const ENV_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;

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

@@ -2,7 +2,7 @@ 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 { TriggerDecl } from "../manifest.ts";
+import type { Trigger } from "../manifest.ts";
 import { makeRouter } from "../router.ts";
 import { evalCorrelation, mountTriggers, runTriggerAction, type SchedulerDeps } from "./triggers.ts";
 
@@ -33,7 +33,7 @@ function fakeApp(): { app: AppApi; calls: EngineCall[]; logs: Array<{ level: str
   return { app, calls, logs };
 }
 
-function fakeCtx(triggers: TriggerDecl[]): { ctx: RuntimeContext; hostLogs: Array<{ level: string; msg: string }> } {
+function fakeCtx(triggers: Trigger[]): { ctx: RuntimeContext; hostLogs: Array<{ level: string; msg: string }> } {
   const hostLogs: Array<{ level: string; msg: string }> = [];
   const ctx = {
     root: "/app",
@@ -113,6 +113,8 @@ test("evalCorrelation returns undefined for a non-scalar result", () => {
 
 test("runTriggerAction starts a process with action.variables", async () => {
   const { app, calls } = fakeApp();
+  // The manifest surface types `variables` as a FEEL string; the runtime helper
+  // (runTriggerAction/resolveActionVariables) also accepts an inline object literal.
   const res = await runTriggerAction(app, { start: "proc-1", variables: { a: 1 } }, {
     body: { ignored: true },
     headers: {},
@@ -207,7 +209,7 @@ test("cron trigger with an invalid spec logs an error and does not schedule", ()
 
 test("cron trigger with no actionable action is not scheduled", () => {
   const { app, logs } = fakeApp();
-  const { ctx } = fakeCtx([{ id: "noop", type: "cron", spec: "0 6 * * *" }]);
+  const { ctx } = fakeCtx([{ id: "noop", type: "cron", spec: "0 6 * * *", action: {} }]);
   const sched = fakeScheduler(0);
   const handle = mountTriggers(ctx, app, sched);
   assert.equal(sched.pending(), 0);

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

@@ -6,7 +6,7 @@
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
 import type { HttpRequest } from "../host.ts";
 import { json, normalizeRoutePath, type Route } from "../router.ts";
-import type { TriggerDecl } from "../manifest.ts";
+import type { Trigger } from "../manifest.ts";
 import { nextCronFire, parseCron } from "./cron.ts";
 
 export interface TriggersHandle extends Mounted {
@@ -112,9 +112,23 @@ function headerRecord(req: HttpRequest): Record<string, string> {
  * of `correlationKey`/`variables`; cron passes a minimal `{ firedAt }` body. Returns what
  * was done.
  */
+/**
+ * The trigger action as the *runtime* helper reads it: the fields `runTriggerAction`
+ * consumes, with `variables` permitting an inline object literal as well as a FEEL string.
+ * The manifest surface keeps `variables` string-only (a FEEL expression);
+ * `resolveActionVariables` tolerates both, so this shape matches runtime behaviour without
+ * loosening the schema. A locked `Trigger["action"]` is assignable to it.
+ */
+export interface RuntimeTriggerAction {
+  start?: string;
+  message?: string;
+  correlationKey?: string;
+  variables?: string | Record<string, unknown>;
+}
+
 export async function runTriggerAction(
   app: AppApi,
-  action: TriggerDecl["action"],
+  action: RuntimeTriggerAction | undefined,
   scope: Scope,
 ): Promise<{ kind: "start" | "message" | "none"; target?: string; correlationKey?: string }> {
   if (!action) return { kind: "none" };
@@ -161,7 +175,7 @@ export function mountTriggers(
   let stopped = false;
 
   // Arm a cron trigger: compute the next UTC fire, sleep until it, fire the action, repeat.
-  const armCron = (trig: TriggerDecl): void => {
+  const armCron = (trig: Trigger): void => {
     const spec = trig.spec;
     if (!spec) {
       ctx.host.log("warn", `trigger "${trig.id}": cron trigger has no spec, skipped`);
@@ -241,7 +255,7 @@ export function mountTriggers(
     arm();
   };
 
-  for (const trig of (ctx.manifest.triggers ?? []) as TriggerDecl[]) {
+  for (const trig of (ctx.manifest.triggers ?? []) as Trigger[]) {
     if (trig.type === "cron") {
       armCron(trig);
       continue;

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

@@ -4,7 +4,7 @@
 
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
 import type { EngineJob, JobHandler, WorkerSubscription } from "../host.ts";
-import { workerJobType, type WorkerDecl } from "../manifest.ts";
+import { workerJobType, type Worker } from "../manifest.ts";
 import { type DecisionEvaluator, type LlmRuntime, runLlmJob } from "./llm.ts";
 
 /** The subset of the engine SDK the LLM decision-rails need: evaluate a DMN decision,
@@ -106,7 +106,7 @@ export async function mountWorkers(ctx: RuntimeContext, app: AppApi): Promise<Wo
     return mod;
   };
 
-  for (const decl of decls as WorkerDecl[]) {
+  for (const decl of decls as Worker[]) {
     const jobType = workerJobType(decl);
     if (!jobType) continue;
     if (!decl.handler) {

package/src/runtime/core/validate.ts

@@ -1,13 +1,14 @@
-// Manifest validation. We deliberately avoid a heavyweight JSON-Schema engine here to
-// keep core dependency-free and runtime-agnostic. Instead we drive validation *from* the
-// vendored nano-app.schema.json (the ADR 0027 source of truth) for the top-level envelope
-// — required keys, allowed keys (additionalProperties:false), the schemaVersion const, and
-// the id slug pattern — and then layer the runtime's binding rules (a worker needs a
-// handler, a data source needs driver+url, a typed table needs fields, a trigger needs
-// id+type). Reading the schema means the envelope check tracks the schema and can't drift
-// from it silently.
+// Manifest validation. We deliberately avoid a heavyweight JSON-Schema engine here to keep
+// core lean and runtime-agnostic. Instead we drive validation *from* the canonical
+// nano-app.schema.json (the ADR 0027 source of truth, imported from the
+// @nanobpm/nano-app-schema package) for the top-level envelope — required keys, allowed keys
+// (additionalProperties:false), the schemaVersion const, and the id slug pattern — and then
+// layer the runtime's binding rules (a worker needs a handler, a data source needs
+// driver+url, a typed table needs fields, a trigger needs id+type). Importing the shared
+// schema JSON means the envelope check tracks the published schema and can't drift from it
+// silently — the whole point of consuming the package rather than vendoring a copy.
 
-import schema from "../schema/nano-app.schema.json" with { type: "json" };
+import schema from "@nanobpm/nano-app-schema/schema" with { type: "json" };
 import { workerJobType, type AppManifest } from "./manifest.ts";
 
 export interface ValidationIssue {
@@ -73,7 +74,7 @@ export function collectManifestIssues(m: unknown): ValidationIssue[] {
   if (Array.isArray(man.workers)) {
     man.workers.forEach((w, i) => {
       if (!workerJobType(w)) {
-        issues.push({ path: `workers[${i}]`, message: "missing taskType/type" });
+        issues.push({ path: `workers[${i}]`, message: "missing taskType" });
       }
       // The schema allows a worker backed by either a `handler` file or an `llm`
       // binding (oneOf). Require exactly one — don't force `handler`.

package/src/runtime/index.ts

@@ -19,13 +19,16 @@ export {
 export type {
   ActionDecl,
   AppManifest,
+  ChatSurface,
   DataSource,
+  DomainField,
   DomainType,
   LlmBinding,
-  SurfaceDecl,
-  TriggerDecl,
-  TypeField,
-  WorkerDecl,
+  PagesSurface,
+  Surfaces,
+  TaskInboxSurface,
+  Trigger,
+  Worker,
 } from "./core/manifest.ts";
 
 // Validation