@sungen/driver-ui 3.1.2-beta.100

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@sungen/driver-ui",
+  "version": "3.1.2-beta.100",
+  "description": "Sungen UI capability (Playwright) — step patterns, viewpoint gate, and phase hooks. Plugs into @sun-asterisk/sungen via the capability SPI.",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "sungen": {
+    "capability": "ui"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json"
+  },
+  "author": "eqe team (engineer & quality) — Sun Asterisk",
+  "license": "MIT",
+  "dependencies": {
+    "@sun-asterisk/sungen": "3.1.2-beta.100"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.57.0"
+  },
+  "files": [
+    "dist",
+    "src"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,119 @@
+/**
+ * @sungen/driver-ui — Sungen UI capability (Playwright).
+ *
+ * The default/implicit capability: a scenario with no capability tag is UI. Owns the step-pattern
+ * vocabulary, the universal viewpoint catalog, the coverage-gate + assertion-depth computation, and
+ * the screen/flow discovery + context hooks. Plugs into core via the capability SPI; core discovers
+ * and calls `register()` at runtime (core never imports this package).
+ *
+ * Relocated from core in R5.4 (was `src/capabilities/builtins.ts` + the in-core pattern files).
+ * Note: the base Playwright spec templates (`specs-base`/`specs-locale`) remain in core for now —
+ * they're emitted by the core generator/initializer, not through this capability; disentangling them
+ * needs the generator abstraction (Orchestration Engine, #287).
+ */
+import type {
+  CapabilityRegistry,
+  Sensor,
+  GateInput,
+  DiscoveryProvider,
+  ContextMapper,
+  GenerationUnit,
+  ScenarioInfo,
+  ViewpointEntry,
+  Catalog,
+  GateResult,
+  DepthResult,
+} from '@sun-asterisk/sungen';
+import { loadCatalog, viewpointGate, assertionDepth, dataThemesFor } from '@sun-asterisk/sungen';
+
+import { setupPatterns } from './patterns/setup-patterns';
+import { navigationPatterns } from './patterns/navigation-patterns';
+import { formPatterns } from './patterns/form-patterns';
+import { interactionPatterns } from './patterns/interaction-patterns';
+import { assertionPatterns } from './patterns/assertion-patterns';
+import { keyboardPatterns } from './patterns/keyboard-patterns';
+import { scrollPatterns } from './patterns/scroll-patterns';
+import { scopePatterns } from './patterns/scope-patterns';
+import { tablePatterns } from './patterns/table-patterns';
+import { capturePatterns } from './patterns/capture-patterns';
+
+/** Inputs the UI gate computation needs (passed by the audit engine via `gateProvider`). */
+export interface UiGateInput {
+  scenarios: ScenarioInfo[];
+  viewpoints: ViewpointEntry[];
+  catalog: Catalog;
+  focus: Parameters<typeof assertionDepth>[2];
+}
+export interface UiGateResult {
+  gate: GateResult;
+  depth: DepthResult;
+}
+
+/**
+ * UI score-bearing gate computation: viewpoint coverage + assertion depth. Wraps the shared sensor
+ * functions verbatim, so the produced gate/depth (and therefore the score) are byte-identical.
+ */
+const uiGateProvider = (input: UiGateInput): UiGateResult => {
+  const gate = viewpointGate(input.scenarios, input.viewpoints, input.catalog);
+  const depth = assertionDepth(input.scenarios, dataThemesFor(input.catalog, gate.pageType), input.focus);
+  return { gate, depth };
+};
+
+/**
+ * UI viewpoint gate sensor: surfaces the universal-viewpoint theme gaps the coverage gate found
+ * (a low-priority reminder — does NOT affect the score or gate verdict).
+ */
+const uiViewpointGateSensor: Sensor<GateInput> = {
+  id: 'ui-viewpoint',
+  capability: 'ui',
+  kind: 'gate',
+  run: ({ universalGaps }) =>
+    universalGaps && universalGaps.length
+      ? [{ sensorId: 'ui-viewpoint', capability: 'ui', message: `UNIVERSAL: missing theme(s): ${universalGaps.join(', ')} (low priority reminder).`, severity: 'info' }]
+      : [],
+};
+
+// UI phase hooks (the pipeline consumes these incrementally; full capture-mode wiring lands later).
+const uiDiscovery: DiscoveryProvider = {
+  appliesTo: (t) => t.kind === 'screen' || t.kind === 'flow',
+  discover: async (target) => ({ target: { ...target, capability: 'ui' }, sources: {}, facts: {} }),
+};
+
+const uiContextMapper: ContextMapper = {
+  decompose: (ctx) => {
+    const f = (ctx.facts || {}) as { screens?: unknown[]; flows?: unknown[] };
+    const units: GenerationUnit[] = [];
+    for (const s of f.screens ?? []) units.push({ mode: 'screen', targetSlice: s });
+    for (const fl of f.flows ?? []) units.push({ mode: 'flow', targetSlice: fl });
+    if (!units.length) units.push({ mode: ctx.target.kind === 'flow' ? 'flow' : 'screen', targetSlice: ctx.target });
+    return units;
+  },
+};
+
+/** Register the UI capability — the default/implicit capability. */
+export function register(registry: CapabilityRegistry): void {
+  registry.register({
+    id: 'ui',
+    default: true,
+    annotations: [],
+    patterns: [
+      ...setupPatterns,
+      ...navigationPatterns,
+      ...formPatterns,
+      ...interactionPatterns,
+      ...assertionPatterns,
+      ...keyboardPatterns,
+      ...scrollPatterns,
+      ...scopePatterns,
+      ...tablePatterns,
+      ...capturePatterns,
+    ],
+    discovery: uiDiscovery,
+    contextMapper: uiContextMapper,
+    viewpoints: loadCatalog, // UI owns the 17-pattern universal viewpoint catalog
+    gateProvider: uiGateProvider as (i: unknown) => unknown, // viewpoint coverage + depth
+    sensors: [uiViewpointGateSensor],
+  });
+}
+
+export const sungenDriver = { capability: 'ui', register } as const;