@wenathlan/cobaia 0.0.0-stage → 2.0.155

package/tests/adsconfig.test.ts

@@ -0,0 +1,51 @@
+// # adsconfig.test — the honest ad slot registry of the family site.
+// Run: pnpm vitest run tests/adsconfig.test.ts
+// The suite watches the promise the ad slot makes: one reserved slot per
+// content page (home, apps, blog), every slot id shipping EMPTY (no ad
+// network script, no id, no key is ever committed — the loader enters after
+// approval through the deploy environment), the fixed visible label, and the
+// aspect-ratio shapes the containers reserve so the page never shifts.
+import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
+import { ADS_EMPTY, ADS_LABEL, ADSSLOTS, adsslotfor, adsslotlive } from "../adsconfig.ts";
+
+describe("the ad slot registry", () => {
+  it("reserves one slot per content page and nothing else", () => {
+    assert.deepEqual(Object.keys(ADSSLOTS), ["home", "apps", "blog"]);
+    assert.deepEqual(
+      Object.values(ADSSLOTS).map((slot) => slot.format),
+      ["display", "in-feed", "in-article"],
+    );
+  });
+
+  it("ships every slot id empty — the honest placeholder", () => {
+    for (const [page, slot] of Object.entries(ADSSLOTS)) {
+      assert.equal(slot.slotid, "", `${page} must not carry a committed ad network id`);
+      assert.equal(adsslotlive(slot), false, `${page} must read as not configured`);
+    }
+  });
+
+  it("labels the container advertisement, visibly and always", () => {
+    assert.equal(ADS_LABEL, "advertisement");
+    assert.ok(ADS_EMPTY.length > 0);
+  });
+
+  it("reserves fixed aspect ratios so the page never shifts", () => {
+    for (const slot of Object.values(ADSSLOTS)) {
+      assert.match(slot.ratio, /^\d+ \/ \d+$/);
+    }
+  });
+
+  it("answers the live contract on real slot ids only", () => {
+    assert.equal(adsslotlive(undefined), false);
+    assert.equal(adsslotlive({ slotid: "  ", format: "display", ratio: "728 / 90" }), false);
+    assert.equal(adsslotlive({ slotid: "ca-pub-0000000000000000", format: "display", ratio: "728 / 90" }), true);
+  });
+
+  it("returns nothing for pages without a slot", () => {
+    expect(adsslotfor("pricing")).toBeUndefined();
+    expect(adsslotfor("support")).toBeUndefined();
+    expect(adsslotfor("legal")).toBeUndefined();
+    expect(adsslotfor("notfound")).toBeUndefined();
+  });
+});

package/tests/checkoutlinks.test.ts

@@ -0,0 +1,73 @@
+// # checkoutlinks.test — the billing configuration of the family site.
+// Run: pnpm vitest run tests/checkoutlinks.test.ts
+// The suite watches the promise the pricing page makes: the three plans
+// exist with the placeholder prices (US$0 / 5 / 19 a month), every checkout
+// href ships EMPTY so the interface renders the honest empty state instead
+// of a dead link, the support channels obey the same rule, and the
+// configured/not-configured contract answers only on real values. The plan
+// prose (names, billing period, blurbs, features) lives in the label
+// manifest — the suite pins that the store carries a sentence for every key
+// the billing table cites, so a card never renders a bare key.
+import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
+import { checkoutlinks, isconfigured, planbyid, supportlinks } from "../checkoutlinks.ts";
+import { LABEL_MANIFEST } from "../labels.ts";
+
+describe("checkout links", () => {
+  it("carries the three honest plans in display order", () => {
+    assert.deepEqual(
+      checkoutlinks().map((plan) => plan.id),
+      ["free", "pro", "studio"],
+    );
+  });
+
+  it("prices the plans at the placeholder us$0 / 5 / 19 a month", () => {
+    const prices = new Map(checkoutlinks().map((plan) => [plan.id, plan.priceusd]));
+    expect(prices.get("free")).toBe(0);
+    expect(prices.get("pro")).toBe(5);
+    expect(prices.get("studio")).toBe(19);
+    for (const plan of checkoutlinks()) {
+      assert.ok(plan.featureKeys.length >= 3, `${plan.id} must list at least three honest features`);
+    }
+  });
+
+  it("answers every plan sentence from the label manifest — zero hardcoded prose", () => {
+    const prose = (key: string): string => (LABEL_MANIFEST as Record<string, string>)[key];
+    for (const plan of checkoutlinks()) {
+      assert.ok(prose(plan.nameKey), `${plan.id} name key must answer from the manifest`);
+      assert.ok(prose(plan.perKey), `${plan.id} period key must answer from the manifest`);
+      assert.ok(prose(plan.blurbKey), `${plan.id} blurb key must answer from the manifest`);
+      for (const featureKey of plan.featureKeys) {
+        assert.ok(prose(featureKey), `${plan.id} feature key must answer from the manifest`);
+      }
+    }
+    assert.equal(prose("pricing.plan.free.name"), "Free");
+    assert.equal(prose("pricing.plan.pro.name"), "Pro");
+    assert.equal(prose("pricing.plan.studio.name"), "Studio");
+    assert.equal(prose("pricing.plan.free.per"), "month");
+  });
+
+  it("ships every checkout href empty — the honest empty state", () => {
+    for (const plan of checkoutlinks()) {
+      assert.equal(plan.href, "", `${plan.id} must not carry a fake checkout link`);
+      assert.equal(isconfigured(plan.href), false, `${plan.id} must read as not configured`);
+    }
+  });
+
+  it("keeps the support channels unconfigured until the owner sets them", () => {
+    assert.equal(supportlinks().sponsors, "");
+    assert.equal(supportlinks().kofi, "");
+    assert.equal(isconfigured(supportlinks().sponsors), false);
+  });
+
+  it("answers the configured contract on real values only", () => {
+    assert.equal(isconfigured(""), false);
+    assert.equal(isconfigured("   "), false);
+    assert.equal(isconfigured("https://buy.stripe.com/example"), true);
+  });
+
+  it("resolves plans by id and nothing else", () => {
+    assert.equal(planbyid("pro")?.id, "pro");
+    assert.equal(planbyid("enterprise"), undefined);
+  });
+});

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("runner-node");
+    assert.deepEqual(pinned, { ok: true, seat: "runner-node", 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("microvm-firecracker");
+    assert.deepEqual(unusual, { ok: true, seat: "microvm-firecracker", 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/storagelane"), 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/storagelane": path.resolve(import.meta.dirname, "../vault/storagelane.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.