@sightmap/sightmap 0.1.0 → 0.2.0

package/README.md

@@ -1,18 +1,30 @@
 # @sightmap/sightmap
 
-Library and CLI for the [Sightmap spec](https://github.com/sightmap/spec).
+Library and CLI for the Sightmap spec.
+
+- **Spec & docs:** [sightmap.org](https://sightmap.org) · [github.com/sightmap/spec](https://github.com/sightmap/spec)
+- **Package:** [`@sightmap/sightmap`](https://www.npmjs.com/package/@sightmap/sightmap) on npm
+- **Source:** [github.com/sightmap/sightmap-js](https://github.com/sightmap/sightmap-js)
 
 A Sightmap is a YAML description of a web app's views, components, and API requests — the runtime semantics agents need to navigate and interact with the app. This package gives a coding agent a reliable, machine-readable toolkit for curating the `.sightmap/` directory in a customer's repo.
 
+```bash
+npm install -D @sightmap/sightmap
+```
+
 ## CLI
 
 ```bash
 sightmap validate [path]                                         # default path: .sightmap
 sightmap lint [path] [--strict] [--rules <list>]
+sightmap check [path] [--stdin] [--level schema|quality]         # combined validate + lint
 sightmap match <url> [path] [--method <m>] [--require-view]
 sightmap explain <query> [path] [--by name|path] [--type view|component|request] [--require-hit]
+sightmap check-conventions [path]                                # default path: .
 ```
 
+`check` powers the WI-2 advisory hooks: `--stdin` reads YAML from stdin and validates it as a virtual `<stdin>` source. `--level schema` skips lint rules; the default `quality` runs both.
+
 Every command supports `--json` for machine-readable output and `--cwd <dir>` for invocation from outside the project.
 
 ### Examples
@@ -52,6 +64,17 @@ $ sightmap explain 'app/(tabs)/index.tsx'
   component  ArcCard            matchedAs=path  src=app/(tabs)/index.tsx
 ```
 
+### `sightmap check-conventions [path]`
+
+Validate that the repo at `<path>` (default `.`) follows the [filename conventions](https://github.com/sightmap/spec/blob/main/docs/repo-conventions.md) for SEPs (`seps/NNNN-{slug}.md`) and conformance fixtures (`conformance/NNN-{slug}.fixture/`). Exit code `0` if clean, `1` if any violations. Pass `--json` for machine-readable output.
+
+```bash
+sightmap check-conventions .
+sightmap check-conventions /path/to/repo --json
+```
+
+Unlike `validate`/`lint`/`match`/`explain`, this command takes a *repo root*, not a `.sightmap/` directory. It only inspects `seps/` and `conformance/`; everything else (including `spec/`, `docs/`, and top-level project files) is ignored.
+
 ### Exit codes
 
 - `0` — success
@@ -103,6 +126,8 @@ const issues = await lint(sightmap, { root: process.cwd() });
 
 `parse()` throws on invalid input; `validate()` returns a non-throwing `Result`. **Downstream packages should consume `validate()`,** not `parse()`. `parse()` is sugar for end-user code that knows the input is valid.
 
+For the canonical spec semantics — schema fields, route glob syntax, scope rules, and the design rationale — see [sightmap.org](https://sightmap.org) and [`spec/v1/schema.md`](https://github.com/sightmap/spec/blob/main/spec/v1/schema.md) in the spec repo.
+
 ### Diagnostics
 
 Lint and validate share a `Diagnostic` shape:
@@ -133,6 +158,10 @@ Codes are stable, kebab-case, and exported as constants:
 | `route-shadowing`             | warning  | `lint`                    |
 | `unknown-source`              | warning  | `lint`                    |
 | `selector-syntax`             | warning  | `lint`                    |
+| `convention.sep-filename`     | error    | `check-conventions`       |
+| `convention.fixture-dirname`  | error    | `check-conventions`       |
+| `convention.invalid-slug`     | error    | `check-conventions`       |
+| `convention.unexpected-file`  | error    | `check-conventions`       |
 
 Renames require an SEP. Future SDK ports (Python, Go) MUST emit identical codes for the same conditions.
 

package/dist/browser-ChD_xQt8.d.ts

@@ -0,0 +1,253 @@
+/**
+ * File-level memory entries — surfaced whenever any definition from this file is active.
+ */
+type Memory = string[];
+/**
+ * Freeform notes surfaced to agents at runtime in the [Guide] section.
+ */
+type Memory1 = string[];
+/**
+ * A CSS selector, or a list of alternative selectors tried in order.
+ */
+type Selector = string | [string, ...string[]];
+/**
+ * A sightmap file: one YAML document under .sightmap/ describing views, components, requests, and memory entries. See https://github.com/sightmap/spec/blob/main/spec/v1/schema.md for the human-readable reference.
+ */
+interface SightmapV1 {
+    /**
+     * Must be 1 for files that conform to this version of the spec.
+     */
+    version: 1;
+    memory?: Memory;
+    views?: View[];
+    /**
+     * Global components — matched against every view.
+     */
+    components?: Component[];
+    /**
+     * Global requests — matched against every view.
+     */
+    requests?: Request[];
+}
+interface View {
+    name: string;
+    /**
+     * Glob pattern matched against the URL pathname. * matches one segment, ** matches any depth.
+     */
+    route: string;
+    description?: string;
+    source?: string;
+    memory?: Memory1;
+    components?: Component[];
+    requests?: Request[];
+}
+interface Component {
+    name: string;
+    selector: Selector;
+    source?: string;
+    description?: string;
+    memory?: Memory1;
+    /**
+     * Nested components. Selectors are scoped to the parent's matched subtree.
+     */
+    children?: Component[];
+}
+interface Request {
+    name: string;
+    /**
+     * Glob pattern. Express-style :param segments normalize to *.
+     */
+    route: string;
+    /**
+     * HTTP method filter. Case-insensitive; commonly GET, POST, PUT, PATCH, DELETE.
+     */
+    method?: string;
+    description?: string;
+    source?: string;
+    request?: Payload;
+    response?: Payload;
+    headers?: string[];
+    memory?: Memory1;
+}
+interface Payload {
+    fields?: Field[];
+}
+interface Field {
+    name: string;
+    type?: string;
+    description?: string;
+}
+
+type Severity = "error" | "warning" | "info";
+interface Diagnostic {
+    severity: Severity;
+    code: string;
+    message: string;
+    file?: string;
+    path?: string;
+    loc?: {
+        line: number;
+        column: number;
+    };
+    source?: string;
+}
+declare const PARSE_ERROR = "parse-error";
+declare const SCHEMA_VALIDATION_FAILED = "schema-validation-failed";
+declare const UNKNOWN_VERSION = "unknown-version";
+declare const MERGE_COLLISION_VIEW = "merge-collision-view";
+declare const MERGE_COLLISION_COMPONENT = "merge-collision-component";
+declare const DUPLICATE_VIEW_NAME = "duplicate-view-name";
+declare const DUPLICATE_ROUTE = "duplicate-route";
+declare const ROUTE_SHADOWING = "route-shadowing";
+declare const UNKNOWN_SOURCE = "unknown-source";
+declare const SELECTOR_SYNTAX = "selector-syntax";
+
+/**
+ * A single-file fragment after parsing and selector normalization.
+ * Branded to prevent querying an unmerged fragment.
+ */
+interface SightmapFragment extends SightmapV1 {
+    readonly __brand: "SightmapFragment";
+    readonly __sourceFile?: string;
+}
+/**
+ * A merged, queryable sightmap produced by `merge()` or `loadDirectory()`.
+ */
+interface Sightmap {
+    readonly version: 1;
+    readonly views: readonly View[];
+    readonly globalComponents: readonly Component[];
+    readonly globalRequests: readonly Request[];
+    readonly fileMemory: readonly {
+        memory: string[];
+        sourceFile: string;
+    }[];
+    /**
+     * Diagnostics produced during merge (e.g. collisions, duplicate names across files).
+     * Lint diagnostics are returned separately by `lint()`.
+     */
+    readonly diagnostics: readonly Diagnostic[];
+    readonly __brand: "Sightmap";
+}
+interface ResolvedView {
+    name: string;
+    route: string;
+    source?: string;
+    description?: string;
+    memory: string[];
+    definedIn: {
+        file: string;
+        line?: number;
+    };
+}
+interface ResolvedComponent {
+    name: string;
+    selector: string[];
+    source?: string;
+    description?: string;
+    memory: string[];
+    parentChain: string[];
+    scope: "global" | "view-scoped";
+    /** Present iff `scope === "view-scoped"`. */
+    scopedToView?: string;
+    definedIn: {
+        file: string;
+        line?: number;
+    };
+}
+interface ResolvedRequest {
+    name: string;
+    route: string;
+    method?: string;
+    source?: string;
+    description?: string;
+    request?: {
+        fields: readonly Field[];
+    };
+    response?: {
+        fields: readonly Field[];
+    };
+    headers?: readonly string[];
+    memory: string[];
+    definedIn: {
+        file: string;
+        line?: number;
+    };
+}
+interface MatchResult {
+    view: ResolvedView | null;
+    components: ResolvedComponent[];
+    requests: ResolvedRequest[];
+    memory: string[];
+}
+type ExplainMatchedAs = "name" | "path" | "name-and-path";
+/**
+ * Discriminated union: narrowing on `type` automatically narrows `entry`.
+ *   if (hit.type === "view") { hit.entry.route; }  // no cast needed
+ */
+type ExplainHit = {
+    type: "view";
+    matchedAs: ExplainMatchedAs;
+    entry: ResolvedView;
+} | {
+    type: "component";
+    matchedAs: ExplainMatchedAs;
+    entry: ResolvedComponent;
+} | {
+    type: "request";
+    matchedAs: ExplainMatchedAs;
+    entry: ResolvedRequest;
+};
+interface ExplainResult {
+    query: string;
+    hits: ExplainHit[];
+}
+/** Result returned by validate() — never throws. */
+type ValidateResult = {
+    ok: true;
+    value: SightmapFragment;
+} | {
+    ok: false;
+    diagnostics: readonly Diagnostic[];
+};
+
+interface ParseOptions {
+    /** Optional source file path; recorded on the fragment for canonical-order merging. */
+    sourceFile?: string;
+}
+/**
+ * Parse a single sightmap file (YAML string or pre-parsed object).
+ * Throws on parse error, missing version, or version mismatch.
+ * Normalizes `selector: string` to `selector: [string]` everywhere.
+ */
+declare function parse(input: string | object, opts?: ParseOptions): SightmapFragment;
+
+/**
+ * Merge fragments into a queryable Sightmap.
+ *
+ * Canonical order: fragments are sorted by `__sourceFile` (code-point order; locale-independent
+ * for cross-environment determinism). Fragments without a `__sourceFile` sort first, and ES2019
+ * sort stability preserves their input order. Within each fragment, declaration order is
+ * preserved. The merged collection's order = (sourceFile order, then declaration order).
+ *
+ * Duplicate view names produce `merge-collision-view` warnings; duplicate global component
+ * names produce `merge-collision-component`. The first occurrence wins.
+ *
+ * Returned arrays are fresh, but element objects (View/Component/Request) are shared with
+ * the input fragments — callers must not mutate them.
+ */
+declare function merge(fragments: SightmapFragment[]): Sightmap;
+
+interface MatchOptions {
+    url: string;
+    method?: string;
+}
+declare function match(sightmap: Sightmap, opts: MatchOptions): MatchResult;
+
+interface ExplainOptions {
+    by?: "name" | "path";
+    type?: "view" | "component" | "request";
+}
+declare function explain(sightmap: Sightmap, query: string, opts?: ExplainOptions): ExplainResult;
+
+export { type Component as C, type Diagnostic as D, type ExplainHit as E, type Field as F, MERGE_COLLISION_COMPONENT as M, PARSE_ERROR as P, ROUTE_SHADOWING as R, type Sightmap as S, UNKNOWN_SOURCE as U, type ValidateResult as V, type SightmapV1 as a, DUPLICATE_ROUTE as b, DUPLICATE_VIEW_NAME as c, type ExplainMatchedAs as d, type ExplainResult as e, MERGE_COLLISION_VIEW as f, type MatchResult as g, type Request as h, type ResolvedComponent as i, type ResolvedRequest as j, type ResolvedView as k, SCHEMA_VALIDATION_FAILED as l, SELECTOR_SYNTAX as m, type Severity as n, type SightmapFragment as o, UNKNOWN_VERSION as p, type View as q, explain as r, match as s, merge as t, parse as u };

package/dist/browser.d.ts

@@ -0,0 +1 @@
+export { E as ExplainHit, d as ExplainMatchedAs, e as ExplainResult, g as MatchResult, i as ResolvedComponent, j as ResolvedRequest, k as ResolvedView, S as Sightmap, o as SightmapFragment, r as explain, s as match, t as merge, u as parse } from './browser-ChD_xQt8.js';

package/dist/browser.js

@@ -0,0 +1,353 @@
+// src/parse.ts
+import yaml from "js-yaml";
+function parse(input, opts = {}) {
+  let doc;
+  if (typeof input === "string") {
+    try {
+      doc = yaml.load(input);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`YAML parse error: ${msg}`);
+    }
+  } else {
+    doc = { ...input };
+  }
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+    throw new Error("Expected sightmap document to be an object at the root");
+  }
+  const obj = doc;
+  if (obj["version"] === void 0) {
+    throw new Error("Missing required `version` field");
+  }
+  if (obj["version"] !== 1) {
+    throw new Error(`Unsupported version: ${String(obj["version"])} (expected 1)`);
+  }
+  if (Array.isArray(obj["components"])) {
+    obj["components"] = obj["components"].map(normalizeComponent);
+  }
+  if (Array.isArray(obj["views"])) {
+    obj["views"] = obj["views"].map((v) => {
+      const out = { ...v };
+      if (Array.isArray(out["components"])) {
+        out["components"] = out["components"].map(normalizeComponent);
+      }
+      return out;
+    });
+  }
+  const fragment = {
+    ...obj,
+    __brand: "SightmapFragment",
+    ...opts.sourceFile !== void 0 ? { __sourceFile: opts.sourceFile } : {}
+  };
+  return fragment;
+}
+function normalizeComponent(c) {
+  if (c["selectors"] !== void 0 && c.selector === void 0) {
+    const name = c.name ?? "(unnamed)";
+    throw new Error(
+      `Component "${name}": use \`selector\` (singular), not \`selectors\` (plural). \`selector\` accepts either a single string or an array of strings.`
+    );
+  }
+  const sel = c.selector;
+  const normalized = {
+    ...c,
+    selector: typeof sel === "string" ? [sel] : sel
+  };
+  if (Array.isArray(c.children)) {
+    normalized.children = c.children.map(normalizeComponent);
+  }
+  return normalized;
+}
+
+// src/diagnostics.ts
+var MERGE_COLLISION_VIEW = "merge-collision-view";
+var MERGE_COLLISION_COMPONENT = "merge-collision-component";
+
+// src/merge.ts
+function merge(fragments) {
+  const sorted = [...fragments].sort((a, b) => {
+    const aFile = a.__sourceFile ?? "";
+    const bFile = b.__sourceFile ?? "";
+    return aFile < bFile ? -1 : aFile > bFile ? 1 : 0;
+  });
+  const views = [];
+  const globalComponents = [];
+  const globalRequests = [];
+  const fileMemory = [];
+  const diagnostics = [];
+  const seenViewNames = /* @__PURE__ */ new Map();
+  const seenComponentNames = /* @__PURE__ */ new Map();
+  for (const f of sorted) {
+    const file = f.__sourceFile ?? "<unknown>";
+    for (const v of f.views ?? []) {
+      const prev = seenViewNames.get(v.name);
+      if (prev !== void 0) {
+        diagnostics.push({
+          severity: "warning",
+          code: MERGE_COLLISION_VIEW,
+          message: `View name "${v.name}" defined in both "${prev}" and "${file}"; first occurrence wins.`,
+          file
+        });
+      } else {
+        seenViewNames.set(v.name, file);
+      }
+      views.push(v);
+    }
+    for (const c of f.components ?? []) {
+      const prev = seenComponentNames.get(c.name);
+      if (prev !== void 0) {
+        diagnostics.push({
+          severity: "warning",
+          code: MERGE_COLLISION_COMPONENT,
+          message: `Component name "${c.name}" defined in both "${prev}" and "${file}"; first occurrence wins.`,
+          file
+        });
+      } else {
+        seenComponentNames.set(c.name, file);
+      }
+      globalComponents.push(c);
+    }
+    for (const r of f.requests ?? []) {
+      globalRequests.push(r);
+    }
+    if (Array.isArray(f.memory) && f.memory.length > 0) {
+      fileMemory.push({ memory: [...f.memory], sourceFile: file });
+    }
+  }
+  return {
+    version: 1,
+    views,
+    globalComponents,
+    globalRequests,
+    fileMemory,
+    diagnostics,
+    __brand: "Sightmap"
+  };
+}
+
+// src/routeMatch.ts
+function canonicalizeUrl(input) {
+  let s = input;
+  const protoMatch = /^[a-z][a-z0-9+.-]*:\/\/[^/]*/i.exec(s);
+  if (protoMatch) {
+    s = s.slice(protoMatch[0].length) || "/";
+  }
+  const hash = s.indexOf("#");
+  if (hash !== -1) s = s.slice(0, hash);
+  const q = s.indexOf("?");
+  if (q !== -1) s = s.slice(0, q);
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return s;
+}
+function routeMatch(pattern, url) {
+  const p = normalizePattern(pattern);
+  const u = canonicalizeUrl(url);
+  const patternSegs = splitSegments(p);
+  const urlSegs = splitSegments(u);
+  return matchSegs(patternSegs, urlSegs);
+}
+function normalizePattern(p) {
+  let s = p.split("/").map((seg) => seg.startsWith(":") ? "*" : seg).join("/");
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return s;
+}
+function splitSegments(path) {
+  if (path === "/" || path === "") return [];
+  const trimmed = path.startsWith("/") ? path.slice(1) : path;
+  return trimmed.split("/");
+}
+function matchSegs(pattern, url) {
+  if (pattern.length === 0 && url.length === 0) return true;
+  if (pattern.length === 0) return false;
+  const head = pattern[0];
+  const rest = pattern.slice(1);
+  if (head === "**") {
+    if (rest.length === 0) return true;
+    for (let i = 0; i <= url.length; i++) {
+      if (matchSegs(rest, url.slice(i))) return true;
+    }
+    return false;
+  }
+  if (url.length === 0) return false;
+  if (head === "*" || head === url[0]) {
+    return matchSegs(rest, url.slice(1));
+  }
+  return false;
+}
+
+// src/resolver.ts
+function resolveByUrl(sightmap, url, method) {
+  let matchedView = null;
+  for (const v of sightmap.views) {
+    if (routeMatch(v.route, url)) {
+      matchedView = v;
+      break;
+    }
+  }
+  const components = [];
+  for (const c of sightmap.globalComponents) {
+    components.push(...flattenComponent(c, [], "global", void 0));
+  }
+  if (matchedView !== null && Array.isArray(matchedView.components)) {
+    for (const c of matchedView.components) {
+      components.push(...flattenComponent(c, [], "view-scoped", matchedView.name));
+    }
+  }
+  const requests = [];
+  const requestPool = [
+    ...sightmap.globalRequests,
+    ...matchedView?.requests ?? []
+  ];
+  for (const req of requestPool) {
+    if (!routeMatch(req.route, url)) continue;
+    if (method !== void 0 && req.method !== void 0 && req.method !== method) continue;
+    requests.push(toResolvedRequest(req));
+  }
+  const memory = [];
+  for (const fm of sightmap.fileMemory) memory.push(...fm.memory);
+  if (matchedView?.memory) memory.push(...matchedView.memory);
+  return {
+    view: matchedView !== null ? toResolvedView(matchedView) : null,
+    components,
+    requests,
+    memory
+  };
+}
+function resolveByName(sightmap, name) {
+  const hits = [];
+  for (const v of sightmap.views) {
+    if (v.name === name) hits.push({ type: "view", matchedAs: "name", entry: toResolvedView(v) });
+  }
+  for (const c of sightmap.globalComponents) {
+    for (const rc of flattenComponent(c, [], "global", void 0)) {
+      if (rc.name === name) hits.push({ type: "component", matchedAs: "name", entry: rc });
+    }
+  }
+  for (const v of sightmap.views) {
+    for (const c of v.components ?? []) {
+      for (const rc of flattenComponent(c, [], "view-scoped", v.name)) {
+        if (rc.name === name) hits.push({ type: "component", matchedAs: "name", entry: rc });
+      }
+    }
+  }
+  for (const r of sightmap.globalRequests) {
+    if (r.name === name) hits.push({ type: "request", matchedAs: "name", entry: toResolvedRequest(r) });
+  }
+  for (const v of sightmap.views) {
+    for (const r of v.requests ?? []) {
+      if (r.name === name) hits.push({ type: "request", matchedAs: "name", entry: toResolvedRequest(r) });
+    }
+  }
+  return hits;
+}
+function resolveBySourcePath(sightmap, path) {
+  const hits = [];
+  for (const v of sightmap.views) {
+    if (v.source === path) hits.push({ type: "view", matchedAs: "path", entry: toResolvedView(v) });
+  }
+  for (const c of sightmap.globalComponents) {
+    for (const rc of flattenComponent(c, [], "global", void 0)) {
+      if (rc.source === path) hits.push({ type: "component", matchedAs: "path", entry: rc });
+    }
+  }
+  for (const v of sightmap.views) {
+    for (const c of v.components ?? []) {
+      for (const rc of flattenComponent(c, [], "view-scoped", v.name)) {
+        if (rc.source === path) hits.push({ type: "component", matchedAs: "path", entry: rc });
+      }
+    }
+  }
+  for (const r of sightmap.globalRequests) {
+    if (r.source === path) hits.push({ type: "request", matchedAs: "path", entry: toResolvedRequest(r) });
+  }
+  return hits;
+}
+function flattenComponent(c, parentChain, scope, scopedToView) {
+  const out = [];
+  const selector = Array.isArray(c.selector) ? c.selector : [c.selector];
+  out.push({
+    name: c.name,
+    selector,
+    ...c.source !== void 0 ? { source: c.source } : {},
+    ...c.description !== void 0 ? { description: c.description } : {},
+    memory: c.memory ? [...c.memory] : [],
+    parentChain: [...parentChain],
+    scope,
+    ...scopedToView !== void 0 ? { scopedToView } : {},
+    definedIn: { file: "<unknown>" }
+  });
+  for (const child of c.children ?? []) {
+    out.push(...flattenComponent(child, [...parentChain, c.name], scope, scopedToView));
+  }
+  return out;
+}
+function toResolvedView(v) {
+  return {
+    name: v.name,
+    route: v.route,
+    ...v.source !== void 0 ? { source: v.source } : {},
+    ...v.description !== void 0 ? { description: v.description } : {},
+    memory: v.memory ? [...v.memory] : [],
+    definedIn: { file: "<unknown>" }
+  };
+}
+function toResolvedRequest(r) {
+  return {
+    name: r.name,
+    route: r.route,
+    ...r.method !== void 0 ? { method: r.method } : {},
+    ...r.source !== void 0 ? { source: r.source } : {},
+    ...r.description !== void 0 ? { description: r.description } : {},
+    ...r.request !== void 0 ? { request: { fields: r.request.fields ?? [] } } : {},
+    ...r.response !== void 0 ? { response: { fields: r.response.fields ?? [] } } : {},
+    ...r.headers !== void 0 ? { headers: r.headers } : {},
+    memory: r.memory ? [...r.memory] : [],
+    definedIn: { file: "<unknown>" }
+  };
+}
+
+// src/match.ts
+function match(sightmap, opts) {
+  return resolveByUrl(sightmap, opts.url, opts.method);
+}
+
+// src/explain.ts
+function explain(sightmap, query, opts = {}) {
+  const byName = opts.by === "path" ? [] : resolveByName(sightmap, query);
+  const byPath = opts.by === "name" ? [] : resolveBySourcePath(sightmap, query);
+  const key = (h) => `${h.type}:${h.entry.name}`;
+  const namedKeys = new Set(byName.map(key));
+  const pathKeys = new Set(byPath.map(key));
+  const merged = [];
+  for (const h of byName) {
+    if (pathKeys.has(key(h))) {
+      merged.push(withMatchedAs(h, "name-and-path"));
+    } else {
+      merged.push(h);
+    }
+  }
+  for (const h of byPath) {
+    if (!namedKeys.has(key(h))) {
+      merged.push(h);
+    }
+  }
+  const filtered = opts.type !== void 0 ? merged.filter((h) => h.type === opts.type) : merged;
+  return { query, hits: filtered };
+}
+function withMatchedAs(h, matchedAs) {
+  switch (h.type) {
+    case "view":
+      return { type: "view", matchedAs, entry: h.entry };
+    case "component":
+      return { type: "component", matchedAs, entry: h.entry };
+    case "request":
+      return { type: "request", matchedAs, entry: h.entry };
+  }
+}
+export {
+  explain,
+  match,
+  merge,
+  parse
+};
+//# sourceMappingURL=browser.js.map