@pylonts/dsl 1.1.5 → 1.1.11

package/dist/index.d.ts

@@ -22,12 +22,23 @@ export * from './convert.js';
 export * from './ref.js';
 export * from './route.js';
 export * from './service.js';
+export * from './controller.js';
 export * from './dao.js';
+export * from './entity.js';
+export * from './expr.js';
+export * from './filter.js';
+export * from './aggregate.js';
+export * from './repository.js';
+export * from './domain-event.js';
+export * from './third-service.js';
+export * from './field-rule.js';
+export * from './exception.js';
 export * from './page.js';
 export * from './curd.js';
 export * from './page-flow.js';
-export * from './provider.js';
 export * from './page-def.js';
 export * from './mermaid-driver.js';
 export * from './navigation.js';
 export * from './popup.js';
+export * from './method.js';
+export { toCamelCase, toPascalCase, toKebabCase } from '@pylonts/core';

package/dist/index.js

@@ -22,12 +22,25 @@ export * from './convert.js';
 export * from './ref.js';
 export * from './route.js';
 export * from './service.js';
+export * from './controller.js';
 export * from './dao.js';
+export * from './entity.js';
+export * from './expr.js';
+export * from './filter.js';
+export * from './aggregate.js';
+export * from './repository.js';
+export * from './domain-event.js';
+export * from './third-service.js';
+export * from './field-rule.js';
+export * from './exception.js';
 export * from './page.js';
 export * from './curd.js';
 export * from './page-flow.js';
-export * from './provider.js';
 export * from './page-def.js';
 export * from './mermaid-driver.js';
 export * from './navigation.js';
 export * from './popup.js';
+export * from './method.js';
+// Naming conversions moved to @pylonts/core; re-exported for compatibility
+// with packages that import them from @pylonts/dsl.
+export { toCamelCase, toPascalCase, toKebabCase } from '@pylonts/core';

package/dist/mermaid-driver.js

@@ -1,10 +1,17 @@
+import { isCall, methodOf } from './flow.js';
 // Mermaid driver: converts a FlowSchema into a Mermaid flowchart (TD).
 // Node ids are hierarchical (n0, n0_0, n0_0_0, ...) so nested sub-flows stay
 // globally unique. A node with a sub-flow renders as a subgraph block whose
-// internals are rendered recursively. ok edges render as -->, conditional
-// edges render as -->|"WHEN"|.
+// internals are rendered recursively. A TryNode renders as a subgraph for its
+// body plus one per catch handler (and finally): body exception ends route to
+// handlers as dashed `catch X` edges, fall-through paths (body return end and
+// handler return ends, through finally when present) continue via the
+// TryNode's outgoing edges, and handler exception ends rethrow via the
+// TryNode's typed throws edges. Guard nodes render as diamonds, FlowEnd nodes
+// as stadium shapes. Normal edges render as -->, conditional edges as
+// -->|"WHEN"|, typed throws and catch routes as dashed edges.
 function escapeLabel(s) {
-    return s.replace(/"/g, '\\"').replace(/\n/g, '<br/>');
+    return s.replace(/"/g, '\\"').replace(/\n/g, '<br/>').replace(/\|/g, '&#124;');
 }
 export function renderFlowMermaid(schema) {
     const lines = ['flowchart TD'];
@@ -17,24 +24,286 @@ export function renderFlowMermaid(schema) {
 }
 function renderFlow(schema, prefix, lines, ids) {
     schema.nodes.forEach((n, i) => ids.set(n, `${prefix}${i}`));
+    const outgoing = new Map();
+    for (const n of schema.nodes)
+        outgoing.set(n, []);
+    for (const e of schema.edges)
+        outgoing.get(e.start).push(e);
     for (const n of schema.nodes) {
         const id = ids.get(n);
-        if (n.flow) {
+        if (isTryNode(n)) {
             lines.push(`    subgraph ${id}["${escapeLabel(n.name)}"]`);
+            renderFlow(n.body, `${id}_b`, lines, ids);
+            lines.push('    end');
+            const handlers = [];
+            const handlerIdx = new Map();
+            for (const c of n.catches) {
+                if (handlerIdx.has(c.handler))
+                    continue; // one handler may serve many catches
+                handlerIdx.set(c.handler, handlers.length);
+                handlers.push(c.handler);
+            }
+            handlers.forEach((h, i) => {
+                lines.push(`    subgraph ${id}_h${i}["${escapeLabel(h.name)}"]`);
+                renderFlow(h, `${id}_h${i}_`, lines, ids);
+                lines.push('    end');
+            });
+            if (n.finally) {
+                lines.push(`    subgraph ${id}_f["${escapeLabel(n.finally.name)}"]`);
+                renderFlow(n.finally, `${id}_f_`, lines, ids);
+                lines.push('    end');
+            }
+        }
+        else if (isFlowNode(n) && n.flow) {
+            lines.push(`    subgraph ${id}["${escapeLabel(renderNodeLabel(n, outgoing.get(n)))}"]`);
             renderFlow(n.flow, `${id}_`, lines, ids);
             lines.push('    end');
         }
         else {
-            lines.push(`    ${id}["${escapeLabel(n.name)}"]`);
+            const shape = renderShape(n, schema, outgoing.get(n));
+            lines.push(`    ${id}${shape.open}${escapeLabel(renderNodeLabel(n, outgoing.get(n)))}${shape.close}`);
         }
     }
     for (const e of schema.edges) {
-        lines.push(renderEdge(e, ids));
+        if (isTryNode(e.start))
+            continue; // rendered by renderTryRoutes
+        if (isTryNode(e.end)) {
+            // entering a TryNode means entering its body
+            lines.push(renderEdgeLine(e, ids.get(e.start), ids.get(e.end.body.start)));
+            continue;
+        }
+        lines.push(renderEdgeLine(e, ids.get(e.start), ids.get(e.end)));
+    }
+    // guard checks: implicit branch edges of the guard itself
+    for (const n of schema.nodes) {
+        if (!isGuard(n))
+            continue;
+        const id = ids.get(n);
+        for (const c of n.checks) {
+            if (c.return) {
+                lines.push(`    ${id} -->|"${escapeLabel(c.when)}"| ${ids.get(schema.returnEnd)}`);
+            }
+            else if (c.exception) {
+                const t = findExceptionEnd(schema, c.exception.name);
+                lines.push(`    ${id} -.->|"${escapeLabel(c.when)} · throw ${escapeLabel(c.exception.name)}"| ${ids.get(t)}`);
+            }
+        }
+    }
+    // ifNode cases: implicit branch edges of the decision node
+    const branchTarget = (t) => (isTryNode(t) ? t.body.start : t);
+    for (const n of schema.nodes) {
+        if (!isIfNode(n))
+            continue;
+        const id = ids.get(n);
+        for (const c of n.cases) {
+            lines.push(`    ${id} -->|"${escapeLabel(c.when)}"| ${ids.get(branchTarget(c.to))}`);
+        }
+        lines.push(`    ${id} -->|"else"| ${ids.get(branchTarget(n.else))}`);
     }
+    // TryNode internal routes
+    for (const n of schema.nodes) {
+        if (isTryNode(n))
+            renderTryRoutes(n, schema, ids, lines);
+    }
+}
+/** Routes of a TryNode: catch edges, fall-through continuation (through
+ *  finally when present), and handler rethrows (also through finally). */
+function renderTryRoutes(n, schema, ids, lines) {
+    const next = schema.edges.filter((e) => e.start === n && e.throws === undefined && e.exception !== true);
+    const rethrows = schema.edges.filter((e) => e.start === n && e.throws !== undefined);
+    for (const c of n.catches) {
+        const end = findExceptionEnd(n.body, c.exception.name);
+        lines.push(`    ${ids.get(end)} -.->|"catch ${escapeLabel(c.exception.name)}"| ${ids.get(c.handler.start)}`);
+    }
+    const continueFrom = (sourceId) => {
+        if (n.finally) {
+            lines.push(`    ${sourceId} --> ${ids.get(n.finally.start)}`);
+            return;
+        }
+        for (const e of next) {
+            lines.push(renderEdgeLine(e, sourceId, ids.get(e.end)));
+        }
+    };
+    continueFrom(ids.get(n.body.returnEnd));
+    const doneHandlers = new Set();
+    for (const c of n.catches) {
+        if (doneHandlers.has(c.handler))
+            continue; // one handler may serve many catches
+        doneHandlers.add(c.handler);
+        // A handler whose every path throws has no fall-through — its return end
+        // is never targeted and stays out of the handler's node list.
+        const handlerReturn = ids.get(c.handler.returnEnd);
+        if (handlerReturn !== undefined)
+            continueFrom(handlerReturn);
+    }
+    if (n.finally) {
+        for (const e of next) {
+            lines.push(renderEdgeLine(e, ids.get(n.finally.returnEnd), ids.get(e.end)));
+        }
+    }
+    const rethrown = new Map();
+    for (const e of rethrows) {
+        for (const c of n.catches) {
+            let names = rethrown.get(c.handler);
+            if (!names) {
+                names = new Set();
+                rethrown.set(c.handler, names);
+            }
+            if (names.has(e.throws.name))
+                continue; // one handler may serve many catches
+            names.add(e.throws.name);
+            const end = findExceptionEnd(c.handler, e.throws.name);
+            if (!end)
+                continue;
+            if (n.finally) {
+                lines.push(`    ${ids.get(end)} -.->|"rethrow ${escapeLabel(e.throws.name)}"| ${ids.get(n.finally.start)}`);
+                lines.push(`    ${ids.get(n.finally.returnEnd)} -.->|"rethrow ${escapeLabel(e.throws.name)}"| ${ids.get(e.end)}`);
+            }
+            else {
+                lines.push(`    ${ids.get(end)} -.->|"rethrow ${escapeLabel(e.throws.name)}"| ${ids.get(e.end)}`);
+            }
+        }
+    }
+}
+/** The exception end of a flow carrying the given exception name. */
+function findExceptionEnd(flow, exceptionName) {
+    const end = flow.nodes.find((n) => isEnd(n) && n.type === 'exception' && n.exception?.name === exceptionName);
+    if (!end) {
+        throw new Error(`flow ${flow.name}: no exception end for ${exceptionName}`);
+    }
+    return end;
+}
+/** Node label: name on the first line, method references (including utils
+ *  predicates of guard checks) on the second, and the data line (slots
+ *  consumed `r:` / produced `w:`) last. */
+function renderNodeLabel(n, outgoing) {
+    if (isEnd(n) || isTryNode(n))
+        return n.name;
+    const lines = [n.name];
+    if (isFlowNode(n) && n.publish) {
+        const payload = n.publish.payload ? ` (${n.publish.payload.name})` : '';
+        lines.push(`publish ${n.publish.event.name}${payload}`);
+    }
+    const refs = [];
+    if (!isIfNode(n)) {
+        refs.push(...(n.methods ?? []));
+        if (isGuard(n)) {
+            for (const c of n.checks) {
+                if (c.check !== undefined && isCall(c.check))
+                    refs.push(c.check);
+            }
+        }
+    }
+    if (refs.length > 0) {
+        const rendered = refs.map((m) => renderMethodRef(methodOf(m))).join(' | ');
+        // Script-compiled nodes carry the full method name themselves.
+        if (rendered !== n.name)
+            lines.push(rendered);
+    }
+    const data = renderDataLine(n, outgoing);
+    if (data !== '')
+        lines.push(data);
+    return lines.join('\n');
+}
+/** Data line: `r:` lists slots the node consumes (reads, call args, decision
+ *  condition slots, and branch-edge conditions decided here), `w:` lists
+ *  slots it produces (writes and call results). */
+function renderDataLine(n, outgoing) {
+    const reads = new Set();
+    const writes = new Set();
+    const addCondition = (c) => {
+        if (c === undefined)
+            return;
+        if (!isCall(c)) {
+            reads.add(c.field.slot.name);
+            return;
+        }
+        for (const t of c.args ?? [])
+            reads.add(t.name);
+    };
+    if (isGuard(n)) {
+        for (const c of n.checks) {
+            for (const t of c.reads ?? [])
+                reads.add(t.name);
+            addCondition(c.check);
+        }
+    }
+    else if (isIfNode(n)) {
+        for (const c of n.cases)
+            addCondition(c.check);
+    }
+    else {
+        for (const t of n.reads ?? [])
+            reads.add(t.name);
+        for (const t of n.writes ?? [])
+            writes.add(t.name);
+        if (isFlowNode(n) && n.publish?.payload)
+            reads.add(n.publish.payload.name);
+    }
+    for (const e of outgoing)
+        addCondition(e.check);
+    if (!isIfNode(n)) {
+        for (const ref of n.methods ?? []) {
+            if (!isCall(ref))
+                continue;
+            for (const t of ref.args ?? [])
+                reads.add(t.name);
+            if (ref.result)
+                writes.add(ref.result.name);
+        }
+    }
+    const parts = [];
+    if (reads.size > 0)
+        parts.push(`r:${[...reads].join(',')}`);
+    if (writes.size > 0)
+        parts.push(`w:${[...writes].join(',')}`);
+    return parts.join(' ');
+}
+/** Display form: owner.name for descriptors, schema.name for container methods. */
+function renderMethodRef(m) {
+    if ('owner' in m)
+        return `${m.owner}.${m.name}`;
+    return `${m.schema.name}.${m.name}`;
+}
+/** Shape derived from topology: guards are diamonds, ends rounded, other
+ *  branching nodes diamonds, else rect. Exception edges (typed or not) do not
+ *  count as branches. The start keeps its rounded shape unless it branches. */
+function renderShape(n, schema, outgoing) {
+    if (isGuard(n))
+        return { open: '{"', close: '"}' };
+    if (isIfNode(n))
+        return { open: '{"', close: '"}' };
+    if (isEnd(n) || outgoing.length === 0)
+        return { open: '(["', close: '"])' };
+    const normal = outgoing.filter((e) => e.exception !== true && e.throws === undefined).length;
+    if (normal >= 2)
+        return { open: '{"', close: '"}' };
+    if (n === schema.start)
+        return { open: '(["', close: '"])' };
+    return { open: '["', close: '"]' };
+}
+function renderEdgeLine(e, startId, endId) {
+    const isException = e.exception === true || e.throws !== undefined;
+    const arrow = isException ? '-.->' : '-->';
+    const throwLabel = e.throws ? `throw ${escapeLabel(e.throws.name)}` : '';
+    const labelParts = [e.when ? escapeLabel(e.when) : '', throwLabel].filter((s) => s !== '');
+    const label = labelParts.length > 0 ? `|"${labelParts.join(' · ')}"|` : '';
+    return `    ${startId} ${arrow}${label} ${endId}`;
+}
+function isEnd(n) {
+    return 'type' in n && (n.type === 'return' || n.type === 'exception');
+}
+function isFlowNode(n) {
+    return !('type' in n);
+}
+function isGuard(n) {
+    return 'type' in n && n.type === 'guard';
+}
+function isTryNode(n) {
+    return 'type' in n && n.type === 'try';
 }
-function renderEdge(e, ids) {
-    const label = e.when ? `|"${escapeLabel(e.when)}"|` : '';
-    return `    ${ids.get(e.start)} -->${label} ${ids.get(e.end)}`;
+function isIfNode(n) {
+    return 'type' in n && n.type === 'if';
 }
 // Page-driven flow renderer: groups pages by their app into swimlane
 // subgraphs, then renders edges across the whole flow.

package/dist/method.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaBase } from './dsl.js';
+export interface MethodSchema extends SchemaBase {
+    /** Owning schema name, e.g. 'payDao'. */
+    owner: string;
+}
+export type SequenceSchema = MethodSchema[];
+export declare function defineMethod(options: {
+    name: string;
+    owner: string;
+    description?: string;
+}): MethodSchema;

package/dist/method.js

@@ -0,0 +1,3 @@
+export function defineMethod(options) {
+    return { name: options.name, owner: options.owner, description: options.description };
+}

package/dist/mysql-driver.js

@@ -33,6 +33,13 @@ function columnType(field) {
             return field.enum.valueType === 'integer' ? 'TINYINT' : 'VARCHAR(20)';
         case 'json':
             return 'JSON';
+        case 'array':
+        case 'object':
+            // Nested fields are wire-format only (third-party messages); table columns cannot nest.
+            throw new Error(`field ${field.name} (${field.type}): nested fields are not supported on table columns`);
+        case 'aggregate':
+            // Aggregate fields are query outputs, never table columns.
+            throw new Error(`field ${field.name} (aggregate): aggregate fields are not supported on table columns`);
     }
 }
 function renderDefault(field) {

package/dist/project.d.ts

@@ -1,16 +1,17 @@
 import { SchemaBase } from './dsl.js';
 import type { TableSchema } from './db.js';
 /** Frontend form factor. Closed enum, extend when new form factors appear. */
-export type FrontType = 'admin' | 'wxmini';
+export type FrontType = 'admin' | 'wxmini' | 'mobile';
 /** A frontend application (e.g. admin console, wechat mini program). */
 export interface FrontAppSchema extends SchemaBase {
     type: FrontType;
     /** Source directory relative to project root, e.g. 'web-admin/'. */
     dir: string;
     /**
-     * Tenant table for this app. When set, all tables with a foreign key
-     * pointing to this table get automatic tenant scoping: the tenant PK
-     * value is injected from `user.id` into all curd operations.
+     * Tenant table for this app. The tenant column of a business table is
+     * deterministic: `{tenant.phrase}_{tenant.pk}` (e.g. shop with pk id →
+     * `shop_id`). Tables carrying that column get automatic tenant scoping;
+     * tables without it are global tables (e.g. system config) — both valid.
      */
     tenant?: TableSchema;
 }

package/dist/project.js

@@ -1,3 +1,12 @@
+// Instance naming: lowercase letters/digits/dashes only. Underscores belong
+// to table names; the instance export symbol in project.config.ts must equal
+// the kebab-camel of the name, so 'admin_api' cannot map to a valid symbol.
+const INSTANCE_NAME_RE = /^[a-z][a-z0-9-]*$/;
+function checkInstanceName(project, kind, name) {
+    if (!INSTANCE_NAME_RE.test(name)) {
+        throw new Error(`project ${project}: ${kind} name '${name}' must match ${INSTANCE_NAME_RE} (lowercase letters/digits/dashes; underscores are table-only)`);
+    }
+}
 /**
  * Defines the project topology. FrontAppSchema instances are shared value objects:
  * api.apps references the same instances from project.apps, so an app served
@@ -12,11 +21,12 @@ export function defineProject(name, schema) {
     for (const app of project.apps) {
         if (!app.name)
             throw new Error(`project ${name}: app name is required`);
+        checkInstanceName(name, 'app', app.name);
         if (appNames.has(app.name))
             throw new Error(`project ${name}: duplicate app name '${app.name}'`);
         appNames.add(app.name);
-        if (app.type !== 'admin' && app.type !== 'wxmini') {
-            throw new Error(`project ${name}: app '${app.name}' must be type 'admin' or 'wxmini' (got '${app.type}')`);
+        if (app.type !== 'admin' && app.type !== 'wxmini' && app.type !== 'mobile') {
+            throw new Error(`project ${name}: app '${app.name}' must be type 'admin', 'wxmini' or 'mobile' (got '${app.type}')`);
         }
         if (!app.dir)
             throw new Error(`project ${name}: app '${app.name}' dir is required`);
@@ -25,6 +35,7 @@ export function defineProject(name, schema) {
     for (const api of project.apis) {
         if (!api.name)
             throw new Error(`project ${name}: api name is required`);
+        checkInstanceName(name, 'api', api.name);
         if (apiNames.has(api.name))
             throw new Error(`project ${name}: duplicate api name '${api.name}'`);
         apiNames.add(api.name);
@@ -39,6 +50,7 @@ export function defineProject(name, schema) {
     for (const third of project.thirdApis) {
         if (!third.name)
             throw new Error(`project ${name}: thirdApi name is required`);
+        checkInstanceName(name, 'thirdApi', third.name);
         if (!third.dir)
             throw new Error(`project ${name}: thirdApi '${third.name}' dir is required`);
     }

package/dist/provider.d.ts

@@ -3,7 +3,7 @@ import type { ImportableSchemaBase } from './dsl.js';
 import type { DtoField, DtoMessage, DtoArrayField, DtoObjectField } from './dto.js';
 import type { ActionSchema } from './action.js';
 import type { RefSchema } from './ref.js';
-import type { ConvertSchema } from './convert.js';
+import type { EndpointSchema } from './endpoint.js';
 /** Parameter data source for a call argument. */
 export type DataRef = {
     type: 'route';
@@ -26,19 +26,16 @@ export interface CallAction extends ActionSchema {
 }
 export declare function call(func: ProviderSchema, args?: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField | RefSchema | string>): CallAction;
 /** Provider function signature. The generated API client exposes one function
- *  per endpoint; ProviderSchema gives that function a name and types. */
+ *  per endpoint; ProviderSchema gives that function a name and a shared signature. */
 export interface ProviderSchema extends ImportableSchemaBase {
     isAsync: boolean;
-    /** Input DTO (buildInput / buildQuery / buildPk result). */
-    args: DtoMessage;
-    /** Output DTO (buildOutput result) or primitive. */
-    results: DtoMessage | number | boolean | string;
+    /** Shared API signature — same instance the backend controller method references. */
+    signature: EndpointSchema;
 }
 /** Define a provider function. */
 export declare function defineProvider(name: string, schema: {
     isAsync: boolean;
-    args: DtoMessage;
-    results: DtoMessage | number | boolean | string;
+    signature: EndpointSchema;
     description?: string;
     importRef?: ImportBase;
 }): ProviderSchema;
@@ -48,7 +45,5 @@ export interface SetDataAction extends ActionSchema {
     type: 'setData';
     call: CallAction;
     field: DtoField;
-    /** Optional field-level transform before assignment. */
-    convert?: ConvertSchema;
 }
-export declare function setData(call: CallAction, field: DtoField, convert?: ConvertSchema): SetDataAction;
+export declare function setData(call: CallAction, field: DtoField): SetDataAction;

package/dist/provider.js

@@ -13,6 +13,6 @@ export function call(func, args) {
 export function defineProvider(name, schema) {
     return { name, ...schema };
 }
-export function setData(call, field, convert) {
-    return { name: 'setData', type: 'setData', call, field, convert };
+export function setData(call, field) {
+    return { name: 'setData', type: 'setData', call, field };
 }

package/dist/repository.d.ts

@@ -0,0 +1,26 @@
+import { SchemaBase } from './dsl.js';
+import type { DomainAggregate } from './aggregate.js';
+/**
+ * Aggregate-grained storage entry. The repository binds one aggregate and
+ * exposes the three fixed operation skeletons (load / save / delete) that the
+ * generator expands from the aggregate structure:
+ *
+ *   save(order)  = tx { rootDao.upsert + memberDao cascade by via FK }
+ *   load(id)     = rootDao.get + memberDao by via FK
+ *   delete(id)   = tx { memberDao delete + rootDao delete }
+ *
+ * Callers face the domain concept (Order), never the tables. DAO stays
+ * single-table; Repository is the multi-table (aggregate) unit; Service is the
+ * use-case unit. Inter-aggregate joins are prohibited — repositories only
+ * reference each other by root ID.
+ */
+export interface RepositorySchema extends SchemaBase {
+    type: 'repository';
+    /** The aggregate this repository persists (shared instance). */
+    aggregate: DomainAggregate;
+}
+export declare function defineRepository(options: {
+    name: string;
+    aggregate: DomainAggregate;
+    description?: string;
+}): RepositorySchema;

package/dist/repository.js

@@ -0,0 +1,8 @@
+export function defineRepository(options) {
+    return {
+        type: 'repository',
+        name: options.name,
+        description: options.description,
+        aggregate: options.aggregate,
+    };
+}

package/dist/service.d.ts

@@ -1,16 +1,38 @@
-import { SchemaBase } from './dsl.js';
-import { FrontAppSchema } from './project.js';
-import type { DtoArrayField, DtoField, DtoMessage, DtoObjectField } from './dto.js';
-/** A frontend service bound to exactly one frontend app. */
+import type { SchemaBase } from './dsl.js';
+import type { FrontAppSchema, ProjectApiSchema } from './project.js';
+import type { DtoMessage } from './dto.js';
+import type { ExceptionSchema } from './exception.js';
+import type { FlowSchema } from './flow.js';
+/** A backend service serving exactly one frontend app (1:1 module). */
 export interface ServiceSchema extends SchemaBase {
     type: 'service';
-    /** The frontend app this service belongs to (shared instance from project.config). */
+    /** The backend api module this service belongs to (shared instance from
+     *  project.config.ts apis). Services are always backend-side, so storage is
+     *  service_schema/{api.name}/{app.name}/service/. */
+    api: ProjectApiSchema;
+    /** The frontend app this service serves (shared instance from project.config). */
     app: FrontAppSchema;
+    /** Methods keyed by name — the map key is written back as the method name. */
+    methods: Record<string, ServiceMethodSchema>;
 }
-export declare function defineService(name: string, app: FrontAppSchema, description?: string): ServiceSchema;
+/** Method input for defineService: type/schema/name are set by the builder. */
+export type ServiceMethodDef = Omit<ServiceMethodSchema, 'type' | 'schema' | 'name'>;
+export declare function defineService(options: {
+    name: string;
+    api: ProjectApiSchema;
+    app: FrontAppSchema;
+    methods: Record<string, ServiceMethodDef>;
+    description?: string;
+}): ServiceSchema;
 /** A method exposed by a service. */
 export interface ServiceMethodSchema extends SchemaBase {
     type: 'method';
-    name: string;
-    fields: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField>;
+    schema: ServiceSchema;
+    args: DtoMessage;
+    results: DtoMessage;
+    /** Exceptions this method may throw (e.g. IOException, CodeException). */
+    throws?: ExceptionSchema[];
+    /** Implementation flow — the method's logic graph. The method carries the
+     *  contract (args/results/throws), the flow carries the structure. */
+    flow?: FlowSchema;
 }