@shortlink-org/portolan 0.1.0

package/catalog/roundtrip_test.go

@@ -0,0 +1,185 @@
+package catalog
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"testing"
+)
+
+// TestRoundTrip is what holds this package to src/catalog.ts.
+//
+// Every real catalog in the repository is unmarshalled into these structs and
+// marshalled straight back out. Anything the mirror does not know about is
+// dropped on the way in and missing on the way out, so a field added to the
+// TypeScript and forgotten here fails as a named path rather than as a blank
+// section in somebody's generated documentation.
+//
+// The comparison is semantic: key order differs by construction, and an
+// optional list that was written as [] is the same fact as one left out.
+func TestRoundTrip(t *testing.T) {
+	files, err := filepath.Glob("../data/*.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(files) == 0 {
+		t.Fatal("no catalogs under ../data - this test proves nothing without one")
+	}
+
+	for _, path := range files {
+		t.Run(filepath.Base(path), func(t *testing.T) {
+			raw, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			var before any
+			if err := json.Unmarshal(raw, &before); err != nil {
+				t.Fatalf("source is not JSON: %v", err)
+			}
+
+			var parsed Catalog
+			if err := json.Unmarshal(raw, &parsed); err != nil {
+				t.Fatalf("catalog does not fit the mirror: %v", err)
+			}
+
+			out, err := json.Marshal(&parsed)
+			if err != nil {
+				t.Fatalf("mirror does not marshal: %v", err)
+			}
+
+			var after any
+			if err := json.Unmarshal(out, &after); err != nil {
+				t.Fatal(err)
+			}
+
+			diffs := compare("catalog", normalize(before), normalize(after))
+			if len(diffs) == 0 {
+				return
+			}
+
+			shown := diffs
+			if len(shown) > 20 {
+				shown = shown[:20]
+			}
+			for _, d := range shown {
+				t.Error(d)
+			}
+			if len(diffs) > len(shown) {
+				t.Errorf("... and %d more", len(diffs)-len(shown))
+			}
+		})
+	}
+}
+
+// normalize drops keys whose value carries no information. An optional list
+// written as [] and one left out entirely say the same thing, and holding the
+// mirror to which of the two it produces would test encoding/json rather than
+// the shape.
+func normalize(v any) any {
+	switch t := v.(type) {
+	case map[string]any:
+		out := make(map[string]any, len(t))
+		for k, item := range t {
+			switch inner := item.(type) {
+			case []any:
+				if len(inner) == 0 {
+					continue
+				}
+			case map[string]any:
+				if len(inner) == 0 {
+					continue
+				}
+			}
+			out[k] = normalize(item)
+		}
+
+		return out
+	case []any:
+		out := make([]any, len(t))
+		for i, item := range t {
+			out[i] = normalize(item)
+		}
+
+		return out
+	default:
+		return v
+	}
+}
+
+// compare walks both trees together and names every place they part, as a path
+// a reader can find in the file.
+func compare(path string, before, after any) []string {
+	switch b := before.(type) {
+	case map[string]any:
+		a, ok := after.(map[string]any)
+		if !ok {
+			return []string{fmt.Sprintf("%s: object in the source, %T after the round trip", path, after)}
+		}
+
+		var diffs []string
+		for _, key := range sortedKeys(b, a) {
+			bv, inSource := b[key]
+			av, inMirror := a[key]
+			switch {
+			case inSource && !inMirror:
+				diffs = append(diffs, fmt.Sprintf("%s.%s: dropped by the mirror (%s)", path, key, brief(bv)))
+			case !inSource && inMirror:
+				diffs = append(diffs, fmt.Sprintf("%s.%s: invented by the mirror (%s)", path, key, brief(av)))
+			default:
+				diffs = append(diffs, compare(path+"."+key, bv, av)...)
+			}
+		}
+
+		return diffs
+	case []any:
+		a, ok := after.([]any)
+		if !ok {
+			return []string{fmt.Sprintf("%s: list in the source, %T after the round trip", path, after)}
+		}
+		if len(b) != len(a) {
+			return []string{fmt.Sprintf("%s: %d entries in the source, %d after the round trip", path, len(b), len(a))}
+		}
+
+		var diffs []string
+		for i := range b {
+			diffs = append(diffs, compare(fmt.Sprintf("%s[%d]", path, i), b[i], a[i])...)
+		}
+
+		return diffs
+	default:
+		if before != after {
+			return []string{fmt.Sprintf("%s: %s became %s", path, brief(before), brief(after))}
+		}
+
+		return nil
+	}
+}
+
+func sortedKeys(maps ...map[string]any) []string {
+	seen := map[string]bool{}
+	for _, m := range maps {
+		for k := range m {
+			seen[k] = true
+		}
+	}
+
+	keys := make([]string, 0, len(seen))
+	for k := range seen {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	return keys
+}
+
+func brief(v any) string {
+	s := fmt.Sprintf("%v", v)
+	if len(s) > 60 {
+		return s[:57] + "..."
+	}
+
+	return s
+}

package/catalog/via_test.go

@@ -0,0 +1,38 @@
+package catalog
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+// TestEdgeViaRoundTrip pins the one field no committed catalog carries: `via`
+// is written by the host after the merge, so the roundtrip over data/*.json
+// never sees it, and the mirror would drop it silently on the way to a
+// generator.
+func TestEdgeViaRoundTrip(t *testing.T) {
+	in := `{"service":"payments.ledger","status":"declared","via":{"flow":"order-accepted","step":"a3"}}`
+
+	var c EventConsumer
+	if err := json.Unmarshal([]byte(in), &c); err != nil {
+		t.Fatal(err)
+	}
+	if c.Via == nil || c.Via.Flow != "order-accepted" || c.Via.Step != "a3" {
+		t.Fatalf("via not read: %+v", c.Via)
+	}
+
+	out, err := json.Marshal(&c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(out) != in {
+		t.Fatalf("round trip changed the consumer:\n got %s\nwant %s", out, in)
+	}
+
+	var call RpcCall
+	if err := json.Unmarshal([]byte(`{"id":"x/Y","peer":"p","status":"declared","source":"s"}`), &call); err != nil {
+		t.Fatal(err)
+	}
+	if call.Via != nil {
+		t.Fatalf("a call without via must round-trip without one: %+v", call.Via)
+	}
+}

package/cli/portolan.mjs

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import {
+  copyFileSync,
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { glob } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const installRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const packageJson = JSON.parse(readFileSync(resolve(installRoot, "package.json"), "utf8"));
+
+export const VERSION = packageJson.version;
+
+export async function main(argv = process.argv.slice(2)) {
+  const parsed = parse(argv);
+  if (parsed.version || parsed.command === "version") {
+    console.log(VERSION);
+    return;
+  }
+  if (parsed.help || !parsed.command) return help();
+
+  const workspace = resolve(parsed.cwd ?? process.cwd());
+  assertWorkspace(workspace);
+  process.chdir(workspace);
+  process.env.PORTOLAN_SCHEMA = resolve(installRoot, "schema/portolan.schema.json");
+  process.env.PORTOLAN_INSTALL_ROOT = installRoot;
+  process.env.PORTOLAN_CLI = fileURLToPath(import.meta.url);
+
+  switch (parsed.command) {
+    case "init":
+      return init(workspace, parsed);
+    case "generate":
+    case "gen":
+      return runScript("scripts/gen.mjs", [], workspace);
+    case "check":
+      return runScript("scripts/gen.mjs", ["--check"], workspace);
+    case "build":
+      return build(workspace, parsed);
+    case "dev":
+      return dev(workspace, parsed);
+    case "diff":
+      if (!parsed.positionals[0]) fail("diff requires a base branch, tag, or commit");
+      return runScript("scripts/diff.mjs", parsed.positionals, workspace);
+    case "doctor":
+      return doctor(workspace);
+    default:
+      fail(`unknown command ${JSON.stringify(parsed.command)}; run portolan --help`);
+  }
+}
+
+function parse(argv) {
+  const value = { command: "", positionals: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") value.help = true;
+    else if (arg === "--version" || arg === "-v") value.version = true;
+    else if (["--cwd", "--output", "--base", "--host", "--port"].includes(arg)) {
+      const next = argv[++index];
+      if (!next) fail(`${arg} requires a value`);
+      value[arg.slice(2)] = next;
+    } else if (arg === "--yes" || arg === "-y") value.yes = true;
+    else if (arg.startsWith("-")) fail(`unknown option ${arg}`);
+    else if (!value.command) value.command = arg;
+    else value.positionals.push(arg);
+  }
+  return value;
+}
+
+function help() {
+  console.log(`Portolan ${VERSION}
+
+Usage: portolan <command> [options]
+
+Commands:
+  init       create a minimal portolan.json for this repository
+  dev        open the local architecture site
+  generate   update catalog fragments, docs, and exports
+  check      fail when committed generated files are out of date
+  build      build the static site
+  diff BASE  describe architecture changes against BASE
+  doctor     check the local runtime and project configuration
+  version    print the CLI version
+
+Options:
+  --cwd DIR       project directory (default: current directory)
+  --output DIR    build output (default: dist)
+  --base PATH     deployed URL base (default: /)
+  --host HOST     dev server host (default: 127.0.0.1)
+  --port PORT     dev server port
+  --yes, -y       accept non-destructive init defaults`);
+}
+
+function init(workspace) {
+  const manifestPath = resolve(workspace, "portolan.json");
+  if (existsSync(manifestPath)) fail("portolan.json already exists; init did not change it");
+
+  const projectPackage = readJson(resolve(workspace, "package.json"));
+  const rawName = String(projectPackage?.name ?? basename(workspace)).replace(/^@[^/]+\//, "");
+  const id = slug(rawName) || "project";
+  const title = titleOf(id);
+  const manifest = {
+    $schema: `https://raw.githubusercontent.com/shortlink-org/portolan/${VERSION}/schema/portolan.schema.json`,
+    sources: ["portolan/*.json"],
+    projects: [{ id, name: title, root: ".", group: id, component: id }],
+    extract: [{
+      plugin: "project",
+      in: ".",
+      out: "portolan",
+      options: { group: id, groupName: title, component: id, componentName: title },
+    }],
+    generate: [
+      { plugin: "markdown", out: "docs", options: { title } },
+      { plugin: "mermaid", out: "exports/mermaid", options: { title: `${title} flows` } },
+    ],
+  };
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { flag: "wx" });
+
+  if (projectPackage) {
+    const scripts = { ...(projectPackage.scripts ?? {}) };
+    const defaults = {
+      "architecture": "portolan dev",
+      "architecture:gen": "portolan generate",
+      "architecture:check": "portolan check",
+      "architecture:build": "portolan build",
+    };
+    for (const [name, command] of Object.entries(defaults)) {
+      if (!(name in scripts)) scripts[name] = command;
+    }
+    writeFileSync(resolve(workspace, "package.json"), `${JSON.stringify({ ...projectPackage, scripts }, null, 2)}\n`);
+  }
+
+  const ignorePath = resolve(workspace, ".gitignore");
+  const ignore = existsSync(ignorePath) ? readFileSync(ignorePath, "utf8") : "";
+  if (!ignore.split(/\r?\n/).includes(".portolan/")) {
+    writeFileSync(ignorePath, `${ignore}${ignore && !ignore.endsWith("\n") ? "\n" : ""}\n# Portolan local build state\n.portolan/\n`);
+  }
+
+  console.log("created portolan.json");
+  if (projectPackage) console.log("added architecture scripts to package.json");
+  console.log("next: portolan generate && portolan dev");
+}
+
+function doctor(workspace) {
+  const checks = [
+    ["Node.js >= 24", Number(process.versions.node.split(".")[0]) >= 24, process.version],
+    ["portolan.json", existsSync(resolve(workspace, "portolan.json")), "required"],
+    ["Git", commandWorks("git", ["--version"]), "used for deterministic source stamps"],
+    ["Go", commandWorks("go", ["version"]), "required by built-in Go extractors"],
+    ["Python 3", commandWorks("python3", ["--version"]), "required by Python extractors"],
+    ["Java", commandWorks("java", ["-version"]), "required by the Java extractor"],
+    ["Cargo", commandWorks("cargo", ["--version"]), "required by the Rust extractor"],
+  ];
+  for (const [label, ok, note] of checks) {
+    console.log(`${ok ? "ok" : "--"}  ${label}${note ? ` — ${note}` : ""}`);
+  }
+  if (!checks[0][1] || !checks[1][1]) process.exitCode = 1;
+}
+
+async function build(workspace, options) {
+  const stage = await prepareSite(workspace);
+  generateLikeC4(stage);
+  const output = safeOutput(workspace, options.output ?? "dist");
+  const env = {
+    ...process.env,
+    PORTOLAN_WORKSPACE: workspace,
+    BASE_PATH: options.base ?? process.env.BASE_PATH ?? "/",
+  };
+  runNode(packageBin("vite", "bin/vite.js"), ["build", stage, "--config", resolve(stage, "vite.config.ts"), "--outDir", output, "--emptyOutDir"], workspace, env);
+
+  const { siteDocs } = await import(resolve(installRoot, "scripts/site-docs.mjs"));
+  const manifest = JSON.parse(readFileSync(resolve(workspace, "portolan.json"), "utf8"));
+  const written = siteDocs({ manifest, dist: output });
+  copyFileSync(resolve(output, "index.html"), resolve(output, "404.html"));
+  console.log(`site: ${relative(workspace, output) || "."}${written.length ? `; mounted ${written.join(", ")}` : ""}`);
+}
+
+async function dev(workspace, options) {
+  const stage = await prepareSite(workspace);
+  generateLikeC4(stage);
+  const args = [stage, "--config", resolve(stage, "vite.config.ts"), "--host", options.host ?? "127.0.0.1"];
+  if (options.port) args.push("--port", options.port, "--strictPort");
+  runNode(packageBin("vite", "bin/vite.js"), args, workspace, {
+    ...process.env,
+    PORTOLAN_WORKSPACE: workspace,
+  });
+}
+
+async function prepareSite(workspace) {
+  const manifestPath = resolve(workspace, "portolan.json");
+  if (!existsSync(manifestPath)) fail("portolan.json is missing; run portolan init first");
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  const stage = resolve(workspace, ".portolan", "site");
+  rmSync(stage, { recursive: true, force: true });
+  mkdirSync(stage, { recursive: true });
+
+  for (const directory of ["src", "public", "scripts"]) {
+    cpSync(resolve(installRoot, directory), resolve(stage, directory), { recursive: true });
+  }
+  for (const file of ["index.html", "vite.config.ts", "tsconfig.json"]) {
+    copyFileSync(resolve(installRoot, file), resolve(stage, file));
+  }
+  writeFileSync(resolve(stage, "package.json"), '{"private":true,"type":"module"}\n');
+
+  const patternSets = [manifest.sources ?? [], ...(manifest.catalogs ?? []).map((profile) => profile.sources ?? [])];
+  const allSources = new Set();
+  for (const patterns of patternSets) {
+    for (const path of await matchedFiles(workspace, patterns)) allSources.add(path);
+  }
+  if (allSources.size === 0) fail("no catalog source matches portolan.json; run portolan generate first");
+
+  const flattened = new Map();
+  let ordinal = 0;
+  for (const source of [...allSources].sort()) {
+    const name = `portolan/source-${String(++ordinal).padStart(4, "0")}.json`;
+    flattened.set(source, name);
+    copyIntoStage(workspace, stage, source, name);
+    copyReferencedFiles(workspace, stage, JSON.parse(readFileSync(resolve(workspace, source), "utf8")));
+  }
+
+  const stagedManifest = {
+    ...manifest,
+    sources: [...flattened.values()],
+    ...(manifest.catalogs ? {
+      catalogs: await Promise.all(manifest.catalogs.map(async (profile) => ({
+        ...profile,
+        sources: (await matchedFiles(workspace, profile.sources ?? [])).map((path) => flattened.get(path)).filter(Boolean),
+      }))),
+    } : {}),
+  };
+  writeFileSync(resolve(stage, "portolan.json"), `${JSON.stringify(stagedManifest, null, 2)}\n`);
+
+  const modules = dependencyRoot();
+  symlinkSync(modules, resolve(stage, "node_modules"), process.platform === "win32" ? "junction" : "dir");
+  return stage;
+}
+
+function generateLikeC4(stage) {
+  runNode(resolve(stage, "scripts/gen-likec4.mjs"), [], stage);
+  runNode(packageBin("likec4", "bin/likec4.mjs"), ["gen", "react", "likec4", "-o", "src/likec4/generated.jsx"], stage);
+}
+
+async function matchedFiles(workspace, patterns) {
+  const found = new Set();
+  for (const pattern of patterns) {
+    if (typeof pattern !== "string" || !pattern) continue;
+    for await (const path of glob(pattern, { cwd: workspace })) {
+      const absolute = resolve(workspace, path);
+      if (inside(workspace, absolute) && statSync(absolute).isFile()) found.add(relative(workspace, absolute).split(sep).join("/"));
+    }
+  }
+  return [...found].sort();
+}
+
+function copyReferencedFiles(workspace, stage, value) {
+  const visit = (item) => {
+    if (Array.isArray(item)) return item.forEach(visit);
+    if (item && typeof item === "object") return Object.values(item).forEach(visit);
+    if (typeof item !== "string" || item.includes("://")) return;
+    const clean = item.replace(/:\d+(?::\d+)?$/, "").replaceAll("\\", "/");
+    if (!clean || isAbsolute(clean) || clean.split("/").includes("..")) return;
+    const source = resolve(workspace, clean);
+    if (!inside(workspace, source) || !existsSync(source) || !statSync(source).isFile()) return;
+    copyIntoStage(workspace, stage, clean, clean);
+  };
+  visit(value);
+}
+
+function copyIntoStage(workspace, stage, source, target) {
+  const from = resolve(workspace, source);
+  const to = resolve(stage, target);
+  if (!inside(workspace, from) || !inside(stage, to)) fail(`unsafe staged path ${source}`);
+  mkdirSync(dirname(to), { recursive: true });
+  copyFileSync(from, to);
+}
+
+function dependencyRoot() {
+  let current = installRoot;
+  while (dirname(current) !== current) {
+    const candidate = resolve(current, "node_modules");
+    if (existsSync(resolve(candidate, ".bin")) && existsSync(resolve(candidate, "vite"))) return candidate;
+    if (basename(current) === "node_modules") return current;
+    current = dirname(current);
+  }
+  fail("could not locate Portolan's installed dependencies");
+}
+
+function packageBin(name, path) {
+  const modules = dependencyRoot();
+  const direct = resolve(modules, name, path);
+  if (existsSync(direct)) return direct;
+  fail(`the installed package is missing ${name}`);
+}
+
+function runScript(path, args, cwd) {
+  const host = prepareHost(cwd);
+  return runNode(resolve(host, path), args, cwd, process.env);
+}
+
+function prepareHost(workspace) {
+  const host = resolve(workspace, ".portolan", "host");
+  rmSync(host, { recursive: true, force: true });
+  mkdirSync(host, { recursive: true });
+  cpSync(resolve(installRoot, "scripts"), resolve(host, "scripts"), { recursive: true });
+  cpSync(resolve(installRoot, "src"), resolve(host, "src"), { recursive: true });
+  writeFileSync(resolve(host, "package.json"), '{"private":true,"type":"module"}\n');
+  symlinkSync(dependencyRoot(), resolve(host, "node_modules"), process.platform === "win32" ? "junction" : "dir");
+  return host;
+}
+
+function runNode(script, args, cwd, env = process.env) {
+  const result = spawnSync(process.execPath, [script, ...args], { cwd, env, stdio: "inherit" });
+  if (result.error) fail(result.error.message);
+  if (result.signal) process.kill(process.pid, result.signal);
+  if (result.status !== 0) process.exit(result.status ?? 1);
+}
+
+function safeOutput(workspace, value) {
+  const output = resolve(workspace, value);
+  if (!inside(workspace, output) || output === workspace) fail("build output must be a directory inside the workspace");
+  return output;
+}
+
+function assertWorkspace(workspace) {
+  if (!existsSync(workspace) || !lstatSync(workspace).isDirectory()) fail(`${workspace} is not a directory`);
+}
+
+function inside(root, target) {
+  const path = relative(resolve(root), resolve(target));
+  return path === "" || (!path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path));
+}
+
+function commandWorks(command, args) {
+  const result = spawnSync(command, args, { stdio: "ignore" });
+  return !result.error && result.status === 0;
+}
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, "utf8")); } catch { return null; }
+}
+
+function slug(value) {
+  return String(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+function titleOf(value) {
+  return value.split("-").filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
+
+function fail(message) {
+  console.error(`portolan: ${message}`);
+  process.exit(1);
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await main();
+}

package/go.mod

@@ -0,0 +1,14 @@
+module github.com/shortlink-org/portolan
+
+go 1.27.0
+
+require (
+	github.com/pgplex/pgparser v0.2.0
+	golang.org/x/tools v0.49.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	golang.org/x/mod v0.39.0 // indirect
+	golang.org/x/sync v0.22.0 // indirect
+)

package/go.sum

@@ -0,0 +1,14 @@
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/pgplex/pgparser v0.2.0 h1:BB7I/Mrwetiw07PTq/AlXcKfajlCwoJfwB7KZ7V9irI=
+github.com/pgplex/pgparser v0.2.0/go.mod h1:DWhK7oZJn/16KTFeOQ+mk78+sRnEYya1XPghIoP9NFU=
+golang.org/x/mod v0.39.0 h1:UF5zwQdCRRUpHfyPwr7d4UrGiVeldIsogtzWVnczL74=
+golang.org/x/mod v0.39.0/go.mod h1:bvIbwjQ0HUFFf5AKukeeYQG4ZBUG9yxQbR9aEweIwYY=
+golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
+golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/tools v0.49.0 h1:3NI7VXzL9+1WZD52Dx2ttoPwD5DWrFGpl9mFZDlmisI=
+golang.org/x/tools v0.49.0/go.mod h1:SJNXV9DBKT0UbdttsQjbfJlAE/q+y36++zo3uL3N0Oo=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <title>portolan</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>