@dikshanty94/webnav 0.2.0

package/dist/explorer/analyse.d.ts

@@ -0,0 +1,25 @@
+import type { StoredActionEffect, ActionRef } from '../mapstore/record.js';
+export interface AnalysedObservation {
+    fromUrl: string;
+    action: ActionRef | null;
+    toUrl: string;
+    navigated: boolean;
+    addedSummary: string[];
+    removedSummary: string[];
+}
+export interface AnalysedSite {
+    node: string;
+    observations: AnalysedObservation[];
+}
+export interface AnalysisResult {
+    sites: AnalysedSite[];
+}
+/**
+ * Structure-NEUTRAL presentation of recorded action-effects. Groups by host
+ * (the only grouping — a convenience), and returns each observation as-is:
+ * what page, what action, where it went, whether it navigated, and a readable
+ * diff summary. webnav imposes NO structure (no states/clusters/edges) — the
+ * calling AGENT reads this and decides the site's structure, then writes it via
+ * graph-edit. The full raw snapshots remain in the record buffer for the agent.
+ */
+export declare function analyseActionEffects(effects: StoredActionEffect[]): AnalysisResult;

package/dist/explorer/analyse.js

@@ -0,0 +1,39 @@
+function host(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return null;
+    }
+}
+const summarize = (nodes) => nodes.map((n) => `${n.role}${n.name ? ` "${n.name}"` : ''}`);
+/**
+ * Structure-NEUTRAL presentation of recorded action-effects. Groups by host
+ * (the only grouping — a convenience), and returns each observation as-is:
+ * what page, what action, where it went, whether it navigated, and a readable
+ * diff summary. webnav imposes NO structure (no states/clusters/edges) — the
+ * calling AGENT reads this and decides the site's structure, then writes it via
+ * graph-edit. The full raw snapshots remain in the record buffer for the agent.
+ */
+export function analyseActionEffects(effects) {
+    const byHost = new Map();
+    for (const e of effects) {
+        // Group by the page the action was taken ON (fromUrl). A navigation
+        // observation (from A → to B) is "what happened on A", so it belongs to A's
+        // host — including the act of leaving for another site. Fall back to toUrl
+        // only when fromUrl has no host (e.g. a null-action initial landing).
+        const h = host(e.fromUrl) ?? host(e.toUrl);
+        if (!h)
+            continue;
+        if (!byHost.has(h))
+            byHost.set(h, []);
+        byHost.get(h).push({
+            fromUrl: e.fromUrl, action: e.action, toUrl: e.toUrl, navigated: e.navigated,
+            addedSummary: summarize(e.diff.added), removedSummary: summarize(e.diff.removed),
+        });
+    }
+    const sites = [...byHost.entries()]
+        .map(([node, observations]) => ({ node, observations }))
+        .sort((a, b) => a.node.localeCompare(b.node));
+    return { sites };
+}

package/dist/explorer/diff.d.ts

@@ -0,0 +1,11 @@
+import type { SnapNode } from '../playwright/snapshot.js';
+export interface SnapshotDiff {
+    added: SnapNode[];
+    removed: SnapNode[];
+}
+/** Mechanical set-difference of two parsed snapshots by node identity
+ *  (role|name|ref). Pure convenience over the raw snapshots — not a judgment. */
+export declare function diffSnapshots(before: SnapNode[], after: SnapNode[]): SnapshotDiff;
+/** Did the action navigate to a different page? Compares host+pathname only
+ *  (query/hash changes are same-page). Unparseable → treat as navigation. */
+export declare function didNavigate(fromUrl: string, toUrl: string): boolean;

package/dist/explorer/diff.js

@@ -0,0 +1,22 @@
+const idOf = (n) => `${n.role}|${n.name ?? ''}|${n.ref ?? ''}`;
+/** Mechanical set-difference of two parsed snapshots by node identity
+ *  (role|name|ref). Pure convenience over the raw snapshots — not a judgment. */
+export function diffSnapshots(before, after) {
+    const beforeIds = new Set(before.map(idOf));
+    const afterIds = new Set(after.map(idOf));
+    return {
+        added: after.filter((n) => !beforeIds.has(idOf(n))),
+        removed: before.filter((n) => !afterIds.has(idOf(n))),
+    };
+}
+/** Did the action navigate to a different page? Compares host+pathname only
+ *  (query/hash changes are same-page). Unparseable → treat as navigation. */
+export function didNavigate(fromUrl, toUrl) {
+    try {
+        const a = new URL(fromUrl), b = new URL(toUrl);
+        return a.host !== b.host || a.pathname !== b.pathname;
+    }
+    catch {
+        return fromUrl !== toUrl;
+    }
+}

package/dist/explorer/draft.d.ts

@@ -0,0 +1,81 @@
+import type { StoredActionEffect } from '../mapstore/record.js';
+import { type ElementFingerprint } from '../playwright/fingerprint.js';
+import { type DeclaredShadow } from '../mapstore/types.js';
+import { type PatternPack } from './patterns.js';
+export interface DraftAffordance {
+    id: string;
+    label: string;
+    kind: 'navigate' | 'input' | 'mutate' | 'reveal';
+    to?: string;
+    elementFp?: ElementFingerprint | null;
+    acceptsInput?: string;
+    needs?: string[];
+    core?: boolean;
+    children?: DraftAffordance[];
+    needsClassification?: boolean;
+    scope?: 'row' | 'widget';
+}
+export declare const COMMIT_WORDS: RegExp;
+export interface DraftState {
+    label: string;
+    urlPattern: string;
+    fingerprint: string[];
+    affordances: DraftAffordance[];
+    template?: string | null;
+    declaredShadow?: DeclaredShadow;
+    role?: 'hub' | 'section' | 'detail' | 'shell';
+    parentState?: string | null;
+    provisional?: string | null;
+    _warning?: string;
+}
+export interface DegenerateState {
+    label: string;
+    urlPattern: string;
+    reason: string;
+    affordances: number;
+}
+export interface Unknown {
+    kind: 'undetected-overlay' | 'ambiguous-cluster' | 'unresolved-affordance' | 'degenerate-landing' | 'pack-tripwire';
+    evidence: string;
+    context: string;
+    extensionPoint: 'overlay-open' | 'value-domain' | 'core-design';
+}
+export interface DraftGraph {
+    states: DraftState[];
+    edges: never[];
+    needsFix?: DegenerateState[];
+    unknowns?: Unknown[];
+    unknownsTruncated?: number;
+    receipt: {
+        entry: string | null;
+        states: string[];
+        walkExample: string | null;
+        requests: string[];
+    };
+}
+export interface TrippedPack {
+    pack: PatternPack;
+    excised: number;
+    total: number;
+}
+/**
+ * Build a draft graph from recorded action-effects. Observation-based identity (2026-07-10):
+ *  1. KEY: infer the site's URL model from every observed url; alias a pre-redirect ghost
+ *     (requestedUrl ≠ settled toUrl) to the settled key so the ghost merges. `key(url)` =
+ *     follow-alias(keyOf(url)) — Task 8's mesh reuses it.
+ *  2. LANDINGS: a page's identity landings = navigated toSnapshots (+ the first effect's
+ *     fromSnapshot) that classifyReadiness==='ready'. Non-nav toSnapshots feed affordances
+ *     only (Task 9), not identity.
+ *  3. PROPOSE/DISPOSE: proposeTemplates over the keys; a group merges iff every member's
+ *     first-landing face is jaccard≥0.5 with the group's first member — same-structure param
+ *     URLs collapse, a list-vs-detail pair does not.
+ *  4. SPA SPLIT: within one key with ≥2 landings, cluster faces at jaccard≥0.5; >1 cluster →
+ *     split states named by a distinguishing heading (else needsFix).
+ *  5. CORE: templateCore(faces) minus shell (shell arrives Task 8); coreNodes = first landing
+ *     filtered to core tokens.
+ *  6. NAME: labelFromKey(template ?? key); collisions broken by a distinguishing core heading
+ *     (else both to needsFix). NO numeric suffixes.
+ * Then (unchanged, some re-pointed in Tasks 8–10): uniqueness fingerprint, affordance synthesis,
+ * hierarchy, self-verify, needsFix assembly.
+ */
+export declare function draftFromEffects(effects: StoredActionEffect[], packs?: PatternPack[]): DraftGraph;