@wenathlan/cobaia 0.0.0-stage → 2.0.158

package/tests/familyurl.test.ts

@@ -0,0 +1,40 @@
+// # familyurl.test — the address book contract of the family deploy units.
+// Run: pnpm vitest run tests/familyurl.test.ts
+// The suite watches the promise the directory and the footer make: every
+// family member resolves one level above this application, always with the
+// trailing slash, and pasted segments or stray slashes land on the same
+// address. Pure string shaping — no network, no side effects.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { familyurl } from "../familyurl.ts";
+
+describe("the familyurl contract", () => {
+  it("resolves a bare slug one level above, with the trailing slash", () => {
+    assert.equal(familyurl("vault"), "../vault/");
+    assert.equal(familyurl("devthink"), "../devthink/");
+  });
+
+  it("trims stray slashes from pasted segments", () => {
+    assert.equal(familyurl("/forge/"), "../forge/");
+    assert.equal(familyurl("forge/"), "../forge/");
+    assert.equal(familyurl("/forge"), "../forge/");
+  });
+
+  it("resolves the whole roster the same way", () => {
+    const roster = [
+      "devthink",
+      "saddle",
+      "forge",
+      "foundry",
+      "vault",
+      "getry",
+      "cadria",
+      "debonair",
+      "stealthhead",
+      "argan",
+    ];
+    for (const slug of roster) {
+      assert.equal(familyurl(slug), `../${slug}/`);
+    }
+  });
+});

package/tests/posts.test.ts

@@ -0,0 +1,76 @@
+// # posts.test — the seed blog of the family site.
+// Run: pnpm vitest run tests/posts.test.ts
+// The suite watches the promise the blog page makes: the index is sorted
+// newest first no matter the array order, the slugs are unique and url-safe,
+// every seed post carries a real ~300 word body (the ad networks approve
+// content, not containers) and the honest word counter agrees with itself.
+import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
+import { postindex, posts, postwords } from "../posts.ts";
+
+// the content lane answers the same rows the seed carries (wave of the
+// content law): the const retired, the accessor serves the identical data
+
+describe("the seed blog", () => {
+  it("carries the three seed posts about the family", () => {
+    assert.equal(posts().length, 3);
+    assert.deepEqual(
+      posts().map((post) => post.slug),
+      ["ten-sites-one-engine", "one-css-one-tree", "no-backend-no-tracking"],
+    );
+  });
+
+  it("indexes the posts newest first", () => {
+    const index = postindex();
+    assert.deepEqual(
+      index.map((post) => post.slug),
+      ["ten-sites-one-engine", "one-css-one-tree", "no-backend-no-tracking"],
+    );
+    for (let i = 1; i < index.length; i++) {
+      assert.ok(index[i - 1].date >= index[i].date, "the index must be sorted by date, newest first");
+    }
+  });
+
+  it("does not mutate the source order when indexing", () => {
+    const before = posts()
+      .map((post) => post.slug)
+      .join(",");
+    postindex();
+    assert.equal(
+      posts()
+        .map((post) => post.slug)
+        .join(","),
+      before,
+    );
+  });
+
+  it("keeps the slugs unique and url-safe", () => {
+    const slugs = posts().map((post) => post.slug);
+    assert.equal(new Set(slugs).size, slugs.length);
+    for (const slug of slugs) {
+      assert.match(slug, /^[a-z0-9]+(-[a-z0-9]+)*$/);
+    }
+  });
+
+  it("dates every post in iso form and before the wave", () => {
+    for (const post of posts()) {
+      assert.match(post.date, /^\d{4}-\d{2}-\d{2}$/);
+      assert.ok(post.date <= "2026-10-10", "a seed post cannot be dated in the future");
+    }
+  });
+
+  it("writes a real ~300 word body for every post", () => {
+    for (const post of posts()) {
+      const words = postwords(post);
+      assert.ok(words >= 250, `${post.slug} carries ${words} words — the seed posts ship real content`);
+      assert.ok(words <= 380, `${post.slug} carries ${words} words — the seed posts stay ~300`);
+      assert.ok(post.excerpt.length > 40, `${post.slug} must carry a real excerpt`);
+      assert.ok(post.body.length >= 3, `${post.slug} must carry more than two paragraphs`);
+    }
+  });
+
+  it("counts words the honest way (split, no empties)", () => {
+    const first = posts()[0];
+    expect(postwords(first)).toBe(first.body.join(" ").split(/\s+/).filter(Boolean).length);
+  });
+});

package/tests/sandboxmodality.test.ts

@@ -0,0 +1,77 @@
+// # sandboxmodality.test — the workload lane declaration of cobaia (wave
+// WL1): the mirrored rows answer the engine catalog byte for byte (the
+// lockstep pin — every lane, role, demand and honest today the engine
+// FAMILYLANES table carries for cobaia, compared through the library
+// bridge so the vendor can never drift in silence), every row names the
+// app slug, and the seat law answers the deploy's opt-in (absent or blank
+// answers the declared local default, "join" opts the lanes onto the
+// platform's join resolver — the nuclear modality law, and a named
+// modality id pins the seat for the platform's join to validate at
+// dispatch — this module never judges engine vocabulary). runnable with
+// vitest:
+//   pnpm vitest run tests/sandboxmodality.test.ts
+import assert from "node:assert/strict";
+import { lanesof } from "@wenathlan/saddle/workloadlaw";
+import { describe, it } from "vitest";
+import { APPSLUG, laneof, lanesandbox, lanesandboxfromenv, SANDBOXLANEENV, WORKLOADLANES } from "../sandboxmodality.ts";
+
+describe("the workload lane mirror (the engine catalog lockstep)", () => {
+  it("answers the engine catalog rows for cobaia — the byte pin", () => {
+    const engine = lanesof("cobaia");
+    assert.equal(engine.length, WORKLOADLANES.length, "the mirror carries every cobaia lane");
+    for (let index = 0; index < engine.length; index += 1) {
+      const row = engine[index];
+      const mirror = WORKLOADLANES[index];
+      assert.equal(mirror.app, row.app);
+      assert.equal(mirror.lane, row.lane, `lane ${index} id drifts from the engine`);
+      assert.equal(mirror.role, row.role, `lane ${row.lane} role drifts from the engine`);
+      assert.deepEqual(mirror.demand, row.demand, `lane ${row.lane} demand drifts from the engine`);
+      assert.equal(mirror.today, row.today, `lane ${row.lane} today drifts from the engine`);
+    }
+  });
+
+  it("carries the app slug on every row and answers the lane lookup", () => {
+    for (const row of WORKLOADLANES) {
+      assert.equal(row.app, APPSLUG);
+    }
+    const first = laneof("plan-checkout");
+    assert.ok(first !== undefined);
+    assert.equal(first.today, "app-lane");
+    assert.equal(laneof("no-such-lane"), undefined);
+  });
+});
+
+describe("the sandbox lane seat (the deploy decides)", () => {
+  it("answers the declared local default when the deploy carries no choice", () => {
+    const absent = lanesandbox(undefined);
+    assert.deepEqual(absent, { ok: true, seat: "local", sandboxed: false });
+    const blank = lanesandbox("   ");
+    assert.deepEqual(blank, { ok: true, seat: "local", sandboxed: false });
+    const explicit = lanesandbox("local");
+    assert.deepEqual(explicit, { ok: true, seat: "local", sandboxed: false });
+  });
+
+  it("opts the lanes onto the platform join when the deploy chooses join", () => {
+    const joined = lanesandbox("join");
+    assert.deepEqual(joined, { ok: true, seat: "join", sandboxed: true, pinned: false });
+    const padded = lanesandbox("  join  ");
+    assert.deepEqual(padded, { ok: true, seat: "join", sandboxed: true, pinned: false });
+  });
+
+  it("pins the named modality for the platform join to validate", () => {
+    const pinned = lanesandbox("runnernode");
+    assert.deepEqual(pinned, { ok: true, seat: "runnernode", sandboxed: true, pinned: true });
+    // the module never judges engine vocabulary: the platform's join
+    // validates the pinned id at dispatch, the mirror only names it
+    const unusual = lanesandbox("microvmfirecracker");
+    assert.deepEqual(unusual, { ok: true, seat: "microvmfirecracker", sandboxed: true, pinned: true });
+  });
+
+  it("reads the seat off the environment lookup the deploy pins", () => {
+    assert.equal(SANDBOXLANEENV, "COBAIA_SANDBOX_LANE");
+    const unset = lanesandboxfromenv(() => undefined);
+    assert.deepEqual(unset, { ok: true, seat: "local", sandboxed: false });
+    const set = lanesandboxfromenv((key) => (key === SANDBOXLANEENV ? "join" : undefined));
+    assert.deepEqual(set, { ok: true, seat: "join", sandboxed: true, pinned: false });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,22 @@
+// the cobaia typescript baseline.
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "noEmit": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "paths": {
+      "@wenathlan/vault/labelstore": ["../vault/labelstore.ts"],
+      "@wenathlan/vault/storagelane": ["../vault/storagelane.ts"]
+    },
+    "strict": true,
+    "lib": ["esnext", "dom", "dom.iterable"],
+    "jsx": "react-jsx",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "allowImportingTsExtensions": true,
+    "types": ["vite/client", "node"]
+  },
+  "include": ["*.ts", "*.tsx", "sol/**/*.ts", "sol/**/*.tsx"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/tsconfig.node.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["vite.config.ts"]
+}

package/vercel.json

@@ -0,0 +1,3 @@
+{
+  "cleanUrls": true
+}

package/vite.config.ts

@@ -0,0 +1,44 @@
+/** Style: cobaia sol — the vite config lives at the app root while the theme stays in sol/: static build emitting the hashed bundles directly into the app root folder (publish = "."), with a repository-scoped base path so the theme answers any deploy root (pages subpath, vercel, netlify, workers). The Tailwind 4 vite plugin compiles the theme stylesheet's `@import "tailwindcss"` head (the @theme source of truth + the light/hcf custom variants). */
+
+import path from "node:path";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+function pagesBasePath(value: string | undefined): string {
+  const candidate = value?.trim() || "/";
+  if (candidate === "." || candidate === "./") return "./";
+  return candidate === "/" ? candidate : `/${candidate.replace(/^\/+|\/+$/g, "")}/`;
+}
+
+export default defineConfig({
+  base: pagesBasePath(process.env.VITE_BASE_PATH),
+  plugins: [react(), tailwindcss()],
+  resolve: {
+    alias: {
+      /** the label store bridge of the ownership law: the app's copy
+       * mechanism rides the vault factory through the published library
+       * specifier ("@wenathlan/vault/labelstore"), and this bridge resolves
+       * the specifier to the monorepo source the sibling engine carries —
+       * the mechanism is never duplicated inside cobaia. the entry retires
+       * when the published envelope carries the built label store. */
+      "@wenathlan/vault/labelstore": path.resolve(import.meta.dirname, "../vault/labelstore.ts"),
+      "@": path.resolve(import.meta.dirname, "Sol"),
+    },
+  },
+  root: import.meta.dirname,
+  build: {
+    outDir: path.resolve(import.meta.dirname, "."),
+    emptyOutDir: false,
+    assetsDir: "",
+  },
+  /** the theme (sol/) and the root logics (checkoutlinks, posts, adsconfig) share one app root, so the dev server allows the app root. */
+  server: {
+    fs: {
+      allow: [import.meta.dirname, path.resolve(import.meta.dirname, "../vault")],
+    },
+    host: true,
+    strictPort: false,
+    allowedHosts: true,
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,42 @@
+import path from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      /** the label store bridge of the ownership law: the app's copy
+       * mechanism rides the vault factory through the published library
+       * specifier ("@wenathlan/vault/labelstore"), and this bridge resolves
+       * the specifier to the monorepo source the sibling engine carries —
+       * the mechanism is never duplicated inside cobaia. the entry retires
+       * when the published envelope carries the built label store. */
+      "@wenathlan/vault/labelstore": path.resolve(import.meta.dirname, "../vault/labelstore.ts"),
+
+      /** the storage lane bridge of the ownership law: the app's sqlite
+       * mechanism rides the vault factory through the published library
+       * specifier ("@wenathlan/vault/storage"), and this bridge resolves
+       * the specifier to the monorepo source the sibling engine carries —
+       * the bootstrap and the helpers are never duplicated inside cobaia.
+       * the entry retires when the published envelope carries the built
+       * storage lane. */
+      "@wenathlan/vault/storage": path.resolve(import.meta.dirname, "../vault/storage.ts"),
+
+      /** the workload law bridge of the family: the app battery pins the
+       * lane mirror against the engine catalog through the published
+       * library specifier ("@wenathlan/saddle/workloadlaw"), and this
+       * bridge resolves the specifier to the monorepo source the sibling
+       * engine carries — the catalog is never duplicated inside cobaia.
+       * the entry retires when the published envelope carries the built
+       * workload law. */
+      "@wenathlan/saddle/workloadlaw": path.resolve(import.meta.dirname, "../saddle/workloadlaw.ts"),
+    },
+  },
+  test: {
+    include: ["tests/*.test.ts"],
+    environment: "node",
+    /* the timeout stays five seconds on every native runner and scales through the env the emulated arm64 container leg sets (a qemu-interpreted second answers the same green suite many times slower), so an emulated runner never fails a test a native runner passed */
+    testTimeout: Number(process.env.COBAIA_TEST_TIMEOUT_MS ?? 5000),
+    hookTimeout: Number(process.env.COBAIA_TEST_TIMEOUT_MS ?? 10000),
+    coverage: { enabled: false },
+  },
+});

package/wrangler.toml

@@ -0,0 +1,7 @@
+# Cloudflare/Workers config (deploy, bindings, domain routes)
+name = "cobaia"
+main = "index.html"
+compatibility_date = "2026-09-29"
+
+[assets]
+directory = "."

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.