@heshammesalam/heshjs 0.2.0 → 0.5.0

package/src/compiler/index.ts

@@ -11,6 +11,7 @@ const f = ts.factory;
 
 export function compile(source: string, options: CompileOptions = {}): Result {
   const ast = parse(source, options.filename);
+  if (ast.contracts.length) throw new HeshError('Architecture declarations require the project compiler (hesh check or hesh({ architecture: ... }))', source, ast.contracts[0]!.start, ast.filename);
   const metadata: Binding[] = [];
   const fail = (message: string, offset: number): never => { throw new HeshError(message, source, offset, ast.filename); };
   const names = new Set<string>();

package/src/destinations/index.ts

@@ -0,0 +1,147 @@
+import { createRouter } from '../router/index.js';
+import { defineModule, useController, useModule, withModuleContext, type RouteLocation } from '../hmvc/index.js';
+import { createDomainGraph, ClientPolicyDenied, type DomainDefinition, type DomainOptions, type DomainGraph } from '../domains/index.js';
+import { signal, effect, onCleanup, scope, type Disposer } from '../reactivity/index.js';
+import { mount, element, text } from '../dom/index.js';
+import type { PresentationState } from '../presentation/index.js';
+export type InputType = 'string' | 'number' | 'boolean';
+export interface TransitionOptions { query?: Record<string, string>; hash?: string; presentation?: 'page' }
+export interface Destination<I extends object> {
+  readonly name: string;
+  href(input: I, options?: TransitionOptions): string;
+  open(input: I, options?: TransitionOptions): void;
+  replace(input: I, options?: TransitionOptions): void;
+  /** Prefetch code/resources, not business data or authorization results. */
+  prefetch(input: I): Promise<void>;
+}
+export interface PresentationContext {
+  domains: Record<string, unknown>;
+  input: Record<string, string | number | boolean>;
+  location: RouteLocation;
+  signal: AbortSignal;
+}
+export interface PresentationResources {
+  create(context: PresentationContext): PresentationState;
+  view(parent: Node, state: PresentationState, destinations: Record<string, Destination<Record<string, unknown>>>): void;
+}
+export interface DestinationDefinition {
+  name: string; url: string; input: Record<string, InputType>; owner: string; access?: string;
+  load(): Promise<PresentationResources>;
+}
+export interface DestinationEvent { type: 'loading' | 'ready' | 'blocked' | 'error' | 'cancelled' | 'disposed'; destination: string; reason?: string }
+export interface ApplicationOptions extends DomainOptions { window?: Window; onError?: (error: unknown) => void; onDiagnostic?: (event: DestinationEvent) => void }
+export interface GraphApplication<D = Record<string, Destination<Record<string, unknown>>>, G = Record<string, Record<string, unknown>>> {
+  destinations: D;
+  domains: G;
+  status: { get(): { phase: 'idle' | 'loading' | 'ready' | 'error'; destination?: string; error?: unknown } };
+  start(parent: Node): Disposer;
+  stop(): void;
+}
+export function validateInput(schema: Record<string, InputType>, input: object): Record<string, string | number | boolean> {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('Destination input must be an object');
+  const values = input as Record<string, unknown>;
+  for (const key of Object.keys(values)) if (!Object.hasOwn(schema, key)) throw new Error(`Unknown destination input ${key}`);
+  const result: Record<string, string | number | boolean> = Object.create(null);
+  for (const [key, type] of Object.entries(schema)) {
+    const value = values[key];
+    if (!Object.hasOwn(values, key) || typeof value !== type || (type === 'number' && !Number.isFinite(value)) || (type === 'string' && !(value as string).length)) throw new Error(`Destination input ${key} must be ${type}${type === 'string' ? ' (nonempty)' : ''}`);
+    if (type === 'string' && (value === '.' || value === '..')) throw new Error(`Destination input ${key} cannot be a URL dot segment`);
+    result[key] = value as string | number | boolean;
+  }
+  return result;
+}
+function decodeInput(definition: DestinationDefinition, params: Readonly<Record<string, string>>): Record<string, string | number | boolean> {
+  const values: Record<string, unknown> = Object.create(null);
+  for (const [key, type] of Object.entries(definition.input)) {
+    const raw = params[key];
+    if (raw === undefined) throw new Error(`Missing URL input ${key}`);
+    if (type === 'boolean' && raw !== 'true' && raw !== 'false') throw new Error(`URL input ${key} must be true/false`);
+    if (type === 'number' && !raw.trim()) throw new Error(`URL input ${key} must be numeric`);
+    values[key] = type === 'number' ? Number(raw) : type === 'boolean' ? raw === 'true' : raw;
+  }
+  return validateInput(definition.input, values);
+}
+export function createGraphApplication(definitions: readonly DomainDefinition[], pages: readonly DestinationDefinition[], options: ApplicationOptions = {}): GraphApplication {
+  const graph = createDomainGraph(definitions, options);
+  const status = signal<{ phase: 'idle' | 'loading' | 'ready' | 'error'; destination?: string; error?: unknown }>({ phase: 'idle' });
+  const report = options.onError ?? (error => console.error(error));
+  const emit = (type: DestinationEvent['type'], destination: string, error?: unknown) => {
+    if (!options.onDiagnostic) return;
+    try { options.onDiagnostic({ type, destination, ...(error === undefined ? {} : { reason: error instanceof Error ? error.message : String(error) }) }); }
+    catch (failure) { report(failure); }
+  };
+  const destinations: Record<string, Destination<Record<string, unknown>>> = Object.create(null);
+  const code = new Map<string, Promise<PresentationResources>>();
+  let stopped = false;
+  const load = (page: DestinationDefinition) => {
+    let result = code.get(page.name);
+    if (!result) { result = Promise.resolve().then(page.load).catch(error => { code.delete(page.name); throw error; }); code.set(page.name, result); }
+    return result;
+  };
+  const authorize = (page: DestinationDefinition) => {
+    if (page.access && options.authorize?.(page.access) !== true) throw new ClientPolicyDenied(page.access, page.name);
+  };
+  const routes = pages.map(page => ({ path: page.url, module: defineModule({
+    model: context => context.route,
+    controller: route => route,
+    view(parent) {
+      const parentContext = useModule();
+      const route = useController<{ get(): RouteLocation }>();
+      effect(() => {
+        const location = route.get();
+        const abort = new AbortController(); let dispose: Disposer | undefined, settled = false;
+        onCleanup(() => { abort.abort(); dispose?.(); emit(settled ? 'disposed' : 'cancelled', page.name); });
+        const message = element(parent, 'p'); message.setAttribute('role', 'status'); text(message, () => 'Loading…');
+        status.set({ phase: 'loading', destination: page.name });
+        emit('loading', page.name);
+        const failed = (error: unknown) => {
+          if (abort.signal.aborted) return;
+          settled = true;
+          message.textContent = 'Unable to open this destination.'; message.setAttribute('role', 'alert');
+          status.set({ phase: 'error', destination: page.name, error }); emit(error instanceof ClientPolicyDenied ? 'blocked' : 'error', page.name, error); report(error);
+        };
+        let input: ReturnType<typeof validateInput>;
+        try { authorize(page); input = decodeInput(page, location.params); } catch (error) { failed(error); return; }
+        void load(page).then(resources => {
+          if (abort.signal.aborted) return;
+          const owned = scope(() => {
+            const state = resources.create({ input, domains: graph.forDomain(page.owner), location, signal: abort.signal });
+            if (state && typeof (state as unknown as { then?: unknown }).then === 'function') throw new Error('Presentation factories must be synchronous; use the provided AbortSignal for async work');
+            mount(() => withModuleContext(parentContext, () => resources.view(parent, state, destinations)), parent, { onError: report });
+          });
+          dispose = owned.dispose;
+          if (abort.signal.aborted) { dispose(); return; }
+          settled = true; message.remove(); status.set({ phase: 'ready', destination: page.name }); emit('ready', page.name);
+          // Page-only focus management; opt-in target or the first heading.
+          const target = (parent as Element).querySelector?.('[data-hesh-focus], h1, h2') as HTMLElement | null | undefined;
+          if (target) { if (!target.hasAttribute('tabindex')) target.setAttribute('tabindex', '-1'); target.focus({ preventScroll: true }); }
+        }).catch(failed);
+      });
+    }
+  }) }));
+  let router: ReturnType<typeof createRouter>;
+  try { router = createRouter({ routes, window: options.window, onError: report }); }
+  catch (error) { graph.dispose(); throw error; }
+  for (const page of pages) {
+    if (destinations[page.name]) { graph.dispose(); throw new Error(`Duplicate destination ${page.name}`); }
+    const href = (input: object, transition: TransitionOptions = {}) => {
+      if (stopped) throw new Error('Application is disposed');
+      if (transition.presentation && transition.presentation !== 'page') throw new Error('Only page presentation is supported');
+      const values = validateInput(page.input, input);
+      const path = page.url.split('/').map(part => part.startsWith(':') ? encodeURIComponent(String(values[part.slice(1)])) : part).join('/');
+      const query = new URLSearchParams(transition.query).toString();
+      const hash = transition.hash ? '#' + encodeURIComponent(transition.hash) : '';
+      return path + (query ? '?' + query : '') + hash;
+    };
+    destinations[page.name] = Object.freeze({ name: page.name, href,
+      open(input: object, transition?: TransitionOptions) { authorize(page); router.navigate(href(input, transition)); },
+      replace(input: object, transition?: TransitionOptions) { authorize(page); router.navigate(href(input, transition), { replace: true }); },
+      async prefetch(input: object) { href(input); await load(page); }
+    });
+  }
+  const stop = () => { if (stopped) return; stopped = true; try { router.stop(); } finally { try { graph.dispose(); } finally { code.clear(); status.set({ phase: 'idle' }); } } };
+  return { destinations: Object.freeze(destinations), domains: graph.domains, status: { get: status.get },
+    start(parent) { if (stopped) throw new Error('Application is disposed'); try { router.start(parent); return stop; } catch (error) { stop(); throw error; } }, stop };
+}
+export { createDomainGraph };
+export type { DomainDefinition, DomainGraph };

package/src/dom/index.ts

@@ -12,7 +12,12 @@ export function mount(component: Component, parent: Node, options: MountOptions
 }
 
 export function element(parent: Node, name: string): HTMLElement {
-  const node = parent.ownerDocument!.createElement(aliases[name] ?? name);
+  return nativeElement(parent, aliases[name] ?? name);
+}
+
+/** Creates the exact HTML tag name, without Hesh shorthand aliases. */
+export function nativeElement(parent: Node, name: string): HTMLElement {
+  const node = parent.ownerDocument!.createElement(name);
   parent.appendChild(node);
   onCleanup(() => node.remove());
   return node;

package/src/domains/index.ts

@@ -0,0 +1,97 @@
+import { scope, type Disposer } from '../reactivity/index.js';
+export interface DomainDefinition {
+  name: string;
+  exposes: readonly string[];
+  consumes: readonly string[];
+  access?: Readonly<Record<string, string>>;
+  factory: (dependencies: Record<string, Record<string, unknown>>) => unknown;
+}
+export interface DomainOptions { authorize?: (policy: string) => boolean }
+export class ClientPolicyDenied extends Error {
+  readonly code = 'HESH-ACCESS-001';
+  constructor(readonly policy: string, readonly contract: string) {
+    super(`Client policy denied: ${policy} (${contract}). Server authorization is still required.`);
+  }
+}
+export interface DomainGraph<T = Record<string, Record<string, unknown>>> {
+  readonly domains: T;
+  forDomain(name: string): Record<string, unknown>;
+  dispose: Disposer;
+}
+const unsafe = new Set(['__proto__', 'constructor', 'prototype']);
+export function contractPath(path: string): string[] {
+  const parts = path.split('.');
+  if (parts.some(p => !p || unsafe.has(p))) throw new Error(`Invalid contract path ${path}`);
+  return parts;
+}
+function project(target: Record<string, unknown>, path: string[], value: unknown): void {
+  const name = path[0]!;
+  if (path.length === 1) { target[name] = value; return; }
+  if (target[name] !== undefined && (typeof target[name] !== 'object' || target[name] === null)) throw new Error(`Overlapping public contracts at ${name}`);
+  const next = (target[name] ??= Object.create(null)) as Record<string, unknown>;
+  project(next, path.slice(1), value);
+}
+function freeze(value: Record<string, unknown>): Record<string, unknown> {
+  for (const child of Object.values(value)) if (child && typeof child === 'object') freeze(child as Record<string, unknown>);
+  return Object.freeze(value);
+}
+function lookup(value: unknown, parts: string[]): { value: unknown; receiver: unknown } {
+  let receiver: unknown;
+  for (const part of parts) {
+    receiver = value;
+    value = value != null && Object.hasOwn(Object(value), part) ? (value as Record<string, unknown>)[part] : undefined;
+  }
+  return { value, receiver };
+}
+export function createDomainGraph(definitions: readonly DomainDefinition[], options: DomainOptions = {}): DomainGraph {
+  const byName = new Map(definitions.map(d => [d.name, d]));
+  if (byName.size !== definitions.length) throw new Error('Duplicate domain name');
+  const domains: Record<string, Record<string, unknown>> = Object.create(null);
+  const contexts: Record<string, Record<string, unknown>> = Object.create(null);
+  const building = new Set<string>();
+  let disposed = false;
+  const owned = scope(() => {
+    const build = (name: string): Record<string, unknown> => {
+      if (domains[name]) return domains[name]!;
+      const definition = byName.get(name);
+      if (!definition) throw new Error(`Missing domain ${name}`);
+      if (building.has(name)) throw new Error(`Circular domain dependency at ${name}`);
+      building.add(name);
+      const dependencies: Record<string, Record<string, unknown>> = Object.create(null);
+      for (const dependency of definition.consumes) {
+        const [provider, ...operation] = contractPath(dependency);
+        if (!operation.length) throw new Error(`Dependency must name an operation: ${dependency}`);
+        const target = build(provider!);
+        const value = lookup(target, operation).value;
+        if (typeof value !== 'function') throw new Error(`Missing public operation ${dependency}`);
+        project(dependencies[provider!] ??= Object.create(null), operation, value);
+      }
+      freeze(dependencies);
+      const implementation = definition.factory(dependencies);
+      if (implementation && typeof (implementation as { then?: unknown }).then === 'function') throw new Error(`Domain ${name} factory must be synchronous`);
+      const facade: Record<string, unknown> = Object.create(null);
+      for (const operation of definition.exposes) {
+        const parts = contractPath(operation);
+        const { value, receiver } = lookup(implementation, parts);
+        if (typeof value !== 'function') throw new Error(`Unresolved implementation ${name}.${operation}`);
+        project(facade, parts, (...args: unknown[]) => {
+          if (disposed) throw new Error('Domain graph is disposed');
+          const policy = definition.access?.[operation];
+          if (policy && options.authorize?.(policy) !== true) throw new ClientPolicyDenied(policy, `${name}.${operation}`);
+          return Reflect.apply(value, receiver, args);
+        });
+      }
+      domains[name] = freeze(facade);
+      contexts[name] = Object.freeze({ ...dependencies, [name]: domains[name] });
+      building.delete(name);
+      return domains[name]!;
+    };
+    for (const definition of definitions) build(definition.name);
+    freeze(domains);
+  });
+  return {
+    domains,
+    forDomain(name) { if (disposed) throw new Error('Domain graph is disposed'); if (!contexts[name]) throw new Error(`Unknown domain context ${name}`); return contexts[name]!; },
+    dispose() { if (disposed) return; disposed = true; owned.dispose(); }
+  };
+}

package/src/heshjs/index.ts

@@ -2,3 +2,5 @@ export { signal, effect, derived, batch, scope, onCleanup, untrack } from '../re
 export type { Signal, Disposer } from '../reactivity/index.js';
 export { mount, element, text, attribute, listen, input, component } from '../dom/index.js';
 export type { Component, MountOptions } from '../dom/index.js';
+export { defineUnit, useUnit, useUnitState, useUnitActions } from '../units/index.js';
+export type { HeshUnit, UnitDefinition } from '../units/index.js';

package/src/hmvc/index.ts

@@ -30,6 +30,13 @@ export interface AppModule {
 }
 let current: { context: ModuleContext; outlet?: Node } | undefined;
 
+/** Restore a captured parent context while mounting an asynchronously loaded screen. */
+export function withModuleContext<T>(context: ModuleContext, run: () => T): T {
+  const previous = current;
+  current = { context };
+  try { return run(); } finally { current = previous; }
+}
+
 export function useModule<M = unknown, C = unknown>(): ModuleContext<M, C> {
   if (!current) throw new Error('Module context is only available during a module view mount');
   return current.context as ModuleContext<M, C>;

package/src/parser/index.ts

@@ -4,7 +4,15 @@ export interface Expression extends Location { source: string }
 export interface State extends Location { kind: 'state' | 'const'; name: string; value: Expression }
 export interface Element extends Location { kind: 'element'; name: string; value?: Expression; handler?: Expression; async: boolean; children: Element[] }
 export interface View extends Location { name: string; exported: boolean; default: boolean; body: (State | Element)[] }
-export interface Module { source: string; filename: string; imports: Expression[]; views: View[] }
+export interface ContractEntry extends Location { name: string; value?: string }
+export interface Contract extends Location {
+  kind: 'domain' | 'presentation' | 'destination' | 'application';
+  name: string;
+  fields: Record<string, ContractEntry>;
+  blocks: Record<string, ContractEntry[]>;
+}
+export interface Module { source: string; filename: string; imports: Expression[]; views: View[]; contracts?: Contract[] }
+export interface ParsedModule extends Module { contracts: Contract[] }
 export class HeshError extends Error {
   readonly line: number;
   readonly column: number;
@@ -61,7 +69,7 @@ export function tokenize(source: string, filename = 'component.hesh'): Token[] {
   return tokens;
 }
 
-export function parse(source: string, filename = 'component.hesh'): Module {
+export function parse(source: string, filename = 'component.hesh'): ParsedModule {
   const tokens = tokenize(source, filename);
   let at = 0;
   const peek = () => tokens[at]?.text;
@@ -119,8 +127,51 @@ export function parse(source: string, filename = 'component.hesh'): Module {
     else take(';');
     return { kind: 'element', name: name.text, start: name.start, end: tokens[at - 1]!.end, value, handler, async, children };
   };
-  const module: Module = { source, filename, imports: [], views: [] };
+  const contract = (): Contract => {
+    const kind = take(); const name = identifier(); take('{');
+    const result: Contract = { kind: kind.text as Contract['kind'], name: name.text, start: kind.start, end: 0, fields: Object.create(null), blocks: Object.create(null) };
+    const schemas: Record<Contract['kind'], Record<string, string>> = {
+      domain: { implementation: 'string', owns: 'list', exposes: 'list', consumes: 'list', access: 'map' },
+      presentation: { html: 'string', logic: 'string', styles: 'string', bindings: 'list', actions: 'list', parts: 'list' },
+      destination: { url: 'string', input: 'map', presentation: 'identifier', access: 'string' },
+      application: { domains: 'list', destinations: 'list' }
+    };
+    const path = (): ContractEntry => {
+      const first = identifier(); let name = first.text;
+      while (peek() === '.') { take(); name += '.' + identifier().text; }
+      for (const part of name.split('.')) if (['__proto__', 'prototype', 'constructor'].includes(part)) fail('Unsafe contract identifier', first.start);
+      return { name, start: first.start, end: tokens[at - 1]!.end };
+    };
+    const string = () => {
+      const token = take();
+      if (token.kind !== ts.SyntaxKind.StringLiteral) fail('Expected quoted string', token.start);
+      const parsed = ts.createSourceFile('literal.js', token.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+      return ((parsed.statements[0] as ts.ExpressionStatement).expression as ts.StringLiteral).text;
+    };
+    while (peek() && peek() !== '}') {
+      const key = take(); const type = Object.hasOwn(schemas[result.kind], key.text) ? schemas[result.kind][key.text] : undefined;
+      if (!type) fail(`Unknown ${result.kind} field ${key.text}`, key.start);
+      if (result.fields[key.text] || result.blocks[key.text]) fail(`Duplicate field ${key.text}`, key.start);
+      if (type === 'string' || type === 'identifier') {
+        take(':'); const value = type === 'string' ? string() : identifier().text; const end = take(';').end;
+        result.fields[key.text] = { name: key.text, value, start: key.start, end };
+      } else {
+        take('{'); const entries: ContractEntry[] = []; const seen = new Set<string>();
+        while (peek() && peek() !== '}') {
+          const entry = path();
+          if (seen.has(entry.name)) fail(`Duplicate entry ${entry.name}`, entry.start); seen.add(entry.name);
+          if (type === 'map') { take(':'); entry.value = key.text === 'input' ? identifier().text : string(); }
+          entry.end = take(';').end; entries.push(entry);
+        }
+        take('}'); result.blocks[key.text] = entries;
+      }
+    }
+    result.end = take('}').end;
+    return result;
+  };
+  const module: ParsedModule = { source, filename, imports: [], views: [], contracts: [] };
   while (tokens[at]) {
+    if (['domain', 'presentation', 'destination', 'application'].includes(peek() ?? '')) { module.contracts.push(contract()); continue; }
     if (peek() === 'import') {
       if (module.views.length) fail('Imports must precede views');
       const start = take().start;
@@ -144,6 +195,6 @@ export function parse(source: string, filename = 'component.hesh'): Module {
     const end = take('}').end;
     module.views.push({ name, body, start, end, exported, default: isDefault });
   }
-  if (!module.views.length) fail('Expected at least one view');
+  if (!module.views.length && !module.contracts.length) fail('Expected at least one view or architecture declaration');
   return module;
 }

package/src/presentation/index.ts

@@ -0,0 +1,33 @@
+import { effect } from '../reactivity/index.js';
+import { nativeElement as element, text, attribute, listen } from '../dom/index.js';
+export { element, text, attribute, listen };
+export { mountPart, unitOutlet } from '../units/index.js';
+import type { HeshUnit } from '../units/index.js';
+export interface PresentationState { bindings: Record<string, unknown>; actions: Record<string, (event: Event) => unknown>; parts?: Record<string, HeshUnit> }
+export function readBinding(bindings: Record<string, unknown>, path: string): unknown {
+  const unwrap = (value: unknown): unknown => {
+    if (typeof value === 'function') return value();
+    if (value && typeof (value as { get?: unknown }).get === 'function') return (value as { get(): unknown }).get();
+    return value;
+  };
+  let value: unknown = bindings;
+  for (const part of path.split('.')) {
+    if (['__proto__', 'constructor', 'prototype'].includes(part)) throw new Error('Unsafe binding path');
+    value = (unwrap(value) as Record<string, unknown> | null)?.[part];
+  }
+  return unwrap(value);
+}
+export function bindValue(node: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement, bindings: Record<string, unknown>, name: string): void {
+  const state = bindings[name] as { get?(): unknown; set?(value: unknown): void };
+  if (typeof state?.get !== 'function' || typeof state.set !== 'function') throw new Error(`h-value ${name} requires a writable signal`);
+  effect(() => { const value = String(state.get!() ?? ''); if (node.value !== value) node.value = value; });
+  listen(node, 'input', () => state.set!(node.value));
+}
+export function bindAction(node: HTMLElement, state: PresentationState, name: string): void {
+  const handler = state.actions[name];
+  if (typeof handler !== 'function') throw new Error(`Missing presentation action ${name}`);
+  listen(node, node.tagName === 'FORM' ? 'submit' : 'click', event => {
+    if (node.tagName === 'FORM') event.preventDefault();
+    return handler.call(state.actions, event);
+  });
+}

package/src/units/index.ts

@@ -0,0 +1,23 @@
+import { defineModule, useController, useModule, Outlet, type AppModule, type ModuleContext } from '../hmvc/index.js';
+import type { PresentationState } from '../presentation/index.js';
+
+export type HeshUnit = AppModule;
+export interface UnitDefinition<S, A extends PresentationState> {
+  state(context: Pick<ModuleContext, 'route' | 'parent'>): S;
+  actions(state: S, context: Pick<ModuleContext, 'route' | 'parent'>): A;
+  screen(parent: Node, state: A, destinations?: object): void;
+  destinations?: object;
+}
+/** Hesh naming over the hierarchical, scope-owned module lifecycle. */
+export function defineUnit<S, A extends PresentationState>(definition: UnitDefinition<S, A>): HeshUnit {
+  return defineModule({ model: definition.state, controller: definition.actions,
+    view(parent) { definition.screen(parent, useController<A>(), definition.destinations); }
+  });
+}
+export function mountPart(parent: Node, state: PresentationState, name: string): void {
+  const part = state.parts?.[name];
+  if (!part || typeof part.attach !== 'function') throw new Error(`Missing Hesh part ${name}`);
+  const context = useModule();
+  part.attach(parent, context.route.get(), context);
+}
+export { Outlet as unitOutlet, useModule as useUnit, useModel as useUnitState, useController as useUnitActions } from '../hmvc/index.js';

package/src/vite/index.ts

@@ -1,17 +1,39 @@
 import type { Plugin } from 'vite';
 import { compile } from '../compiler/index.js';
-export function hesh(): Plugin {
+import { createArchitectureCompiler, writeProject, formatDiagnostic, type ProjectOptions } from '../architecture/index.js';
+import { resolve } from 'node:path';
+export function hesh(options: { architecture?: ProjectOptions } = {}): Plugin {
   let production = false;
+  const architecture = createArchitectureCompiler();
+  let project: ProjectOptions | undefined;
+  let watched: string[] = [];
+  let warn: ((message: string) => void) | undefined;
+  const check = () => {
+    if (!project) return;
+    const result = architecture.check(project);
+    if (result.diagnostics.some(item => item.severity === 'error')) throw new Error(result.diagnostics.map(formatDiagnostic).join('\n'));
+    for (const item of result.diagnostics) if (item.severity === 'warning') warn?.(formatDiagnostic(item));
+    writeProject(result); watched = result.files;
+  };
   return {
     name: 'heshjs', enforce: 'pre',
     config() { return { appType: 'spa' }; },
-    configResolved(config) { production = config.command === 'build'; },
+    configResolved(config) {
+      production = config.command === 'build';
+      warn = message => config.logger.warn(message);
+      if (options.architecture) { project = { ...options.architecture, root: resolve(config.root, options.architecture.root) }; check(); }
+    },
+    buildStart() { for (const file of watched) this.addWatchFile(file); },
     transform(source, id) {
+      if (project && /(?:^|\/)server(?:\/|$)|\.server\.[cm]?[jt]s$/.test(id.replace(/\\/g, '/'))) throw new Error(`HESH-SEC-001 Server-only module cannot enter the browser bundle: ${id}`);
       if (!id.endsWith('.hesh')) return;
       const result = compile(source, { filename: id, development: !production });
       return { code: result.code, map: null };
     },
     handleHotUpdate(context) {
+      if (project && (watched.includes(context.file.replace(/\\/g, '/').toLowerCase()) || watched.includes(context.file.replace(/\\/g, '/')))) {
+        check(); context.server.ws.send({ type: 'full-reload' }); return [];
+      }
       if (context.file.endsWith('.hesh')) { context.server.ws.send({ type: 'full-reload' }); return []; }
     }
   };