create-ailk 0.1.0 → 0.2.0

package/dist/sync-routes.js

@@ -0,0 +1,350 @@
+/**
+ * `create-ailk sync-routes` — bring an already-scaffolded site's route tree up
+ * to the template's (#4986).
+ *
+ * A site scaffolded from an older create-ailk lacks the route directories the
+ * template gained since (the recommender routes of #4891, say). This command
+ * names them — with the `@working-theory/*` release line that first carried
+ * each, from `ROUTE_SINCE` in surfaces.ts — and, with `--apply`, copies them
+ * in through the SAME copier a scaffold uses, so a synced route is
+ * byte-identical to a freshly scaffolded one.
+ *
+ * Three rules shape it:
+ *
+ *   - Scope follows the registry. Every core route dir is checked; a gateable
+ *     surface's route dirs are checked only when the site carries that surface
+ *     (any of its `routes` exists as a directory). A surface gated off at
+ *     scaffold time is deliberate absence, not drift — it is reported as
+ *     skipped, never as missing.
+ *   - Expected bytes are what `copyTemplate` would write. The copier's
+ *     text/binary + marker rules are NOT re-implemented here: the template's
+ *     route root is copied once into a scratch dir and compared from there.
+ *   - Never overwrite, never delete. A route dir the site has changed is
+ *     reported as modified and left alone; `--apply` only creates directories
+ *     that do not exist, so a second run is a no-op.
+ *
+ * Pure module: no `import.meta.url`, so jest can import it directly. The
+ * package's own `templates/` dir is supplied by programmatic.ts.
+ */
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { parseArgs } from "node:util";
+import { copyTemplate } from "./copy.js";
+import { substituteMarkers } from "./substitute.js";
+import { GATEABLE_SURFACES, NON_ROUTE_DIRS, ROUTE_DEPENDENCIES, ROUTE_MESSAGE_NAMESPACES, ROUTE_SINCE, surfaceForRouteDir, } from "./surfaces.js";
+/** Template-relative prefix every `apps/web` route directory sits under. */
+const ROUTE_ROOT = "apps/web/app/[locale]";
+/**
+ * The template's route directories, ROUTE_ROOT-relative and sorted.
+ *
+ * A route directory is a directory under ROUTE_ROOT (not the root itself)
+ * that directly holds at least one regular file, is not inside a
+ * `NON_ROUTE_DIRS` tree (`__tests__`, `components`), and whose top segment
+ * the registry recognizes (`surfaceForRouteDir`).
+ */
+export function listTemplateRouteDirs(templatesDir) {
+    const root = join(templatesDir, ROUTE_ROOT);
+    const out = [];
+    const stack = [""];
+    while (stack.length > 0) {
+        const rel = stack.pop();
+        if (rel === undefined)
+            break;
+        let hasFile = false;
+        for (const entry of readdirSync(join(root, rel), { withFileTypes: true })) {
+            if (entry.isFile()) {
+                hasFile = true;
+            }
+            else if (entry.isDirectory() && !NON_ROUTE_DIRS.has(entry.name)) {
+                stack.push(rel === "" ? entry.name : `${rel}/${entry.name}`);
+            }
+        }
+        if (rel !== "" && hasFile && surfaceForRouteDir(rel) !== undefined) {
+            out.push(rel);
+        }
+    }
+    return out.sort();
+}
+/** Build the report entry for a route dir, insisting on a manifest entry. */
+function reportFor(route) {
+    const since = ROUTE_SINCE[route];
+    if (since === undefined) {
+        throw new Error(`template route dir "${route}" has no ROUTE_SINCE entry — add one in src/surfaces.ts`);
+    }
+    // Every listed route dir has a recognized top segment by construction.
+    return {
+        route,
+        surface: surfaceForRouteDir(route) ?? "core",
+        since,
+        dependencies: ROUTE_DEPENDENCIES[route] ?? [],
+        messageNamespaces: ROUTE_MESSAGE_NAMESPACES[route] ?? [],
+    };
+}
+/**
+ * Whether any DIRECT file of the expected route dir is absent from, or differs
+ * byte-for-byte in, the target's copy. Non-recursive: nested directories are
+ * route dirs of their own, or `__tests__`.
+ */
+function isModified(expectedDir, targetDir) {
+    for (const entry of readdirSync(expectedDir, { withFileTypes: true })) {
+        if (!entry.isFile())
+            continue;
+        const targetFile = join(targetDir, entry.name);
+        if (!existsSync(targetFile))
+            return true;
+        const expected = readFileSync(join(expectedDir, entry.name));
+        if (!expected.equals(readFileSync(targetFile)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Compare an already-scaffolded repo's route tree with the template's and,
+ * when `apply` is set, copy in the route dirs it is missing.
+ *
+ * Throws Error on a missing target, a non-directory target, a directory with
+ * no `architecture.yaml`, or a template route dir without a `ROUTE_SINCE`
+ * entry; the CLI's top-level catch turns that into a `[create-ailk] <message>`
+ * stderr write + exit 1.
+ */
+export function syncRoutes(opts) {
+    const targetAbs = resolve(opts.targetDir);
+    if (!existsSync(targetAbs)) {
+        throw new Error(`sync target does not exist: ${targetAbs}. Point sync-routes at an already-scaffolded repo.`);
+    }
+    if (!statSync(targetAbs).isDirectory()) {
+        throw new Error(`sync target is not a directory: ${targetAbs}`);
+    }
+    if (!existsSync(join(targetAbs, "architecture.yaml"))) {
+        throw new Error(`not a scaffolded repo: no architecture.yaml at ${targetAbs}. Run \`create-ailk <target-dir>\` to scaffold first.`);
+    }
+    // Presence of any of a surface's route dirs means the site carries it.
+    const carried = new Set();
+    const skippedSurfaces = [];
+    for (const surface of GATEABLE_SURFACES) {
+        const present = surface.routes.some((r) => {
+            const p = join(targetAbs, r);
+            return existsSync(p) && statSync(p).isDirectory();
+        });
+        if (present)
+            carried.add(surface.id);
+        else
+            skippedSurfaces.push(surface.id);
+    }
+    skippedSurfaces.sort();
+    const inScope = listTemplateRouteDirs(opts.templatesDir)
+        .map(reportFor)
+        // "authed" (#5014): the `(authed)` route group ships unconditionally in
+        // every scaffold today, the same as "core" — it is checked regardless of
+        // `carried`, which only tracks GATEABLE_SURFACES opt-in.
+        .filter((r) => r.surface === "core" || r.surface === "authed" || carried.has(r.surface));
+    // Identical to scaffoldSync's defaults, so a synced route matches a fresh
+    // scaffold of the same target byte-for-byte.
+    const markers = {
+        PROJECT_NAME: basename(targetAbs),
+        COMPANY_NAME: "Your Company",
+        COMPANY_DOMAIN: "example.com",
+    };
+    const templateRouteRoot = join(opts.templatesDir, ROUTE_ROOT);
+    const targetRouteRoot = join(targetAbs, ROUTE_ROOT);
+    const missing = [];
+    const modified = [];
+    const scratch = mkdtempSync(join(tmpdir(), "ailk-sync-routes-"));
+    try {
+        copyTemplate({
+            templatesDir: templateRouteRoot,
+            targetDir: scratch,
+            versions: opts.versions,
+            markers,
+        });
+        for (const report of inScope) {
+            const targetRoute = join(targetRouteRoot, report.route);
+            if (!existsSync(targetRoute)) {
+                missing.push(report);
+            }
+            else if (isModified(join(scratch, report.route), targetRoute)) {
+                modified.push(report);
+            }
+        }
+    }
+    finally {
+        rmSync(scratch, { recursive: true, force: true });
+    }
+    // #5014 third clause: a route's ROUTE_DEPENDENCIES files must exist in the
+    // target too, or `--apply` leaves a route that cannot compile. Computed
+    // from `missing` only — a route already present is assumed to already have
+    // brought its own dependencies along (or the site owner has otherwise
+    // satisfied them); re-checking every IN-SCOPE route's dependencies on every
+    // run would report a pre-existing, unrelated gap as if this sync caused it.
+    const missingDependencies = [
+        ...new Set(missing.flatMap((r) => r.dependencies.filter((dep) => !existsSync(join(targetAbs, dep))))),
+    ].sort();
+    const missingMessageNamespaces = [
+        ...new Set(missing.flatMap((r) => r.messageNamespaces.filter((ns) => !hasMessageNamespace(targetAbs, ns)))),
+    ].sort();
+    const applied = [];
+    const appliedDependencies = [];
+    if (opts.apply === true) {
+        const missingRoutes = missing.map((r) => r.route);
+        for (const route of missingRoutes) {
+            applied.push(route);
+            // An ancestor route dir's subtree copy already brings this one.
+            if (missingRoutes.some((m) => route.startsWith(m + "/")))
+                continue;
+            const dst = resolve(join(targetRouteRoot, route));
+            if (!dst.startsWith(targetAbs + sep)) {
+                throw new Error(`refusing to write outside target dir: ${dst}`);
+            }
+            copyTemplate({
+                templatesDir: join(templateRouteRoot, route),
+                targetDir: dst,
+                versions: opts.versions,
+                markers,
+            });
+        }
+        for (const dep of missingDependencies) {
+            const dst = resolve(join(targetAbs, dep));
+            if (!dst.startsWith(targetAbs + sep)) {
+                throw new Error(`refusing to write outside target dir: ${dst}`);
+            }
+            copyDependencyFile(join(opts.templatesDir, dep), dst, markers);
+            appliedDependencies.push(dep);
+        }
+    }
+    return {
+        targetDir: targetAbs,
+        checked: inScope.length,
+        missing,
+        modified,
+        applied,
+        missingDependencies,
+        appliedDependencies,
+        missingMessageNamespaces,
+        skippedSurfaces,
+    };
+}
+/**
+ * Whether `apps/web/messages/en.json` in `targetAbs` already declares
+ * `namespace` (a dot-path, e.g. `"waitlistDashboard.gate"`). Missing or
+ * unparseable `messages/en.json` reads as "namespace absent" rather than
+ * throwing — a sync check should report a gap, not crash on one.
+ */
+function hasMessageNamespace(targetAbs, namespace) {
+    const messagesPath = join(targetAbs, "apps/web/messages/en.json");
+    if (!existsSync(messagesPath))
+        return false;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- arbitrary consumer JSON
+        let node = JSON.parse(readFileSync(messagesPath, "utf8"));
+        for (const key of namespace.split(".")) {
+            if (node === null || typeof node !== "object" || !(key in node)) {
+                return false;
+            }
+            node = node[key];
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Copy one dependency file from the template into the target, applying the
+ * same marker substitution `copyTemplate` applies to text files — every
+ * `ROUTE_DEPENDENCIES` entry is `.ts`/`.tsx`, always text. Never overwrites:
+ * the caller (`syncRoutes`) only calls this for a path already confirmed
+ * absent from the target, but the check is repeated here so this helper is
+ * safe to call on its own.
+ */
+function copyDependencyFile(src, dst, markers) {
+    if (existsSync(dst))
+        return;
+    mkdirSync(dirname(dst), { recursive: true });
+    const text = readFileSync(src, "utf8");
+    writeFileSync(dst, substituteMarkers(text, markers));
+}
+/** Render the report the CLI prints after a run. Ends with a newline. */
+export function formatSyncRoutesReport(result, apply) {
+    const lines = [`[create-ailk] sync-routes: ${result.targetDir}`];
+    const entry = (r) => `  ${r.route}  (surface: ${r.surface}, added in ${r.since})`;
+    if (result.missing.length === 0) {
+        // A site with local edits is not "in sync" — say precisely what holds.
+        lines.push(result.modified.length === 0
+            ? `[create-ailk] Routes in sync with the template (${result.checked} route(s) checked).`
+            : `[create-ailk] No template routes missing (${result.checked} route(s) checked).`);
+    }
+    else if (apply) {
+        lines.push(`[create-ailk] Copied ${result.applied.length} route(s):`);
+        lines.push(...result.missing.map(entry));
+    }
+    else {
+        lines.push(`[create-ailk] ${result.missing.length} template route(s) missing:`);
+        lines.push(...result.missing.map(entry));
+    }
+    if (result.modified.length > 0) {
+        lines.push(`[create-ailk] ${result.modified.length} template route(s) modified locally (left as-is):`);
+        lines.push(...result.modified.map((r) => `  ${r.route}  (surface: ${r.surface})`));
+    }
+    if (result.skippedSurfaces.length > 0) {
+        lines.push(`[create-ailk] Surfaces this site does not carry (skipped): ${result.skippedSurfaces.join(", ")}`);
+    }
+    // #5014 third clause: the routes/messages/lib a synced route needs to
+    // compile, reported (and, for lib files, applied) alongside the route.
+    if (result.missingDependencies.length > 0) {
+        lines.push(apply
+            ? `[create-ailk] Also copied ${result.appliedDependencies.length} dependency file(s) the above route(s) import:`
+            : `[create-ailk] Also required — ${result.missingDependencies.length} file(s) the above route(s) import:`);
+        lines.push(...result.missingDependencies.map((dep) => `  ${dep}`));
+    }
+    if (result.missingMessageNamespaces.length > 0) {
+        lines.push(`[create-ailk] Also required — message namespace(s) not found in apps/web/messages/en.json (add manually, not auto-merged):`);
+        lines.push(...result.missingMessageNamespaces.map((ns) => `  ${ns}`));
+    }
+    if (result.missing.length > 0 && !apply) {
+        lines.push("Run `create-ailk sync-routes <target> --apply` to copy the missing routes.");
+    }
+    return lines.join("\n") + "\n";
+}
+export const SYNC_ROUTES_HELP = `create-ailk sync-routes — copy template routes an existing site is missing.
+
+Usage:
+  create-ailk sync-routes [<target-dir>] [--apply]
+
+Arguments:
+  <target-dir>             An already-scaffolded repo (contains
+                           architecture.yaml). Defaults to the current dir.
+
+Options:
+  --apply                  Copy the missing route directories into the target.
+                           Without it the command only reports: exit 1 when a
+                           route is missing, 0 when in sync.
+  --help, -h               Print this message.
+
+Checks every core route plus the routes of each surface the site carries; a
+surface gated off at scaffold time is skipped, not drift. A route the site has
+changed locally is reported and never overwritten. Nothing is ever deleted.
+`;
+/**
+ * Parse the argv AFTER the `sync-routes` word. Strict `node:util` parseArgs,
+ * like `parseCliArgs`; at most one positional.
+ */
+export function parseSyncRoutesArgs(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        strict: true,
+        allowPositionals: true,
+        options: {
+            apply: { type: "boolean", default: false },
+            help: { type: "boolean", default: false, short: "h" },
+        },
+    });
+    if (parsed.positionals.length > 1) {
+        throw new Error(`expected at most one target directory, got ${parsed.positionals.length}`);
+    }
+    return {
+        target: parsed.positionals[0],
+        apply: parsed.values.apply === true,
+        help: parsed.values.help === true,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-ailk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Scaffolder for AI Launch Kit — `pnpm create ailk@latest <dir>` produces a starter repo consuming @working-theory/* from npm (per ADR 0007).",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,20 +11,24 @@
   "files": [
     "dist",
     "templates",
+    "component-catalog.md",
     "README.md",
     "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "tar": "^7.5.21"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tailwind-ai/ai-launch-kit.git",
+    "url": "git+https://github.com/working-theory-labs/ai-launch-kit.git",
     "directory": "packages/create-ailk"
   },
-  "homepage": "https://github.com/tailwind-ai/ai-launch-kit/tree/main/packages/create-ailk#readme",
+  "homepage": "https://github.com/working-theory-labs/ai-launch-kit/tree/main/packages/create-ailk#readme",
   "bugs": {
-    "url": "https://github.com/tailwind-ai/ai-launch-kit/issues"
+    "url": "https://github.com/working-theory-labs/ai-launch-kit/issues"
   },
   "engines": {
     "node": ">=20.0.0"
@@ -37,11 +41,14 @@
   ],
   "license": "Apache-2.0",
   "scripts": {
+    "lint": "tsx ../../scripts/lint-package.ts",
     "build": "tsc -b",
     "type-check": "tsc --noEmit",
     "test": "tsc -b && node scripts/build-templates.mjs && jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
-    "build-templates": "node scripts/build-templates.mjs"
+    "build-templates": "node scripts/build-templates.mjs",
+    "build-catalog": "node scripts/build-component-catalog.mjs",
+    "check-catalog": "node scripts/build-component-catalog.mjs --check"
   }
 }

package/templates/.claude/rules/architecture.md

@@ -19,7 +19,7 @@ other.
 
 - Need to share code between apps? Find an existing `@working-theory/*` package
   that fits, or open an issue upstream at
-  <https://github.com/tailwind-ai/ai-launch-kit> requesting a new one.
+  <https://github.com/working-theory-labs/ai-launch-kit> requesting a new one.
   Do not vendor a copy.
 - Need types shared across apps? Use `@working-theory/validation` (Zod schemas)
   or `@working-theory/schema` (schema.org types).
@@ -55,7 +55,11 @@ better than a quiet violation.
 
 These never appear in source code:
 
-- `sk_live_*`, `pk_live_*` — live Stripe keys live in your deployment
+- Any Stripe key that is not a test-mode key. The runtime guard is an
+  ALLOW-LIST — it accepts `sk_test_`, `pk_test_`, `rk_test_` and refuses
+  everything else, so every live key is refused, restricted (`rk_live_`)
+  and future prefixes included, by being absent from the list rather than
+  by being named on a ban-list. Live keys live in your deployment
   platform's secrets store, never in source files or `.env`.
 - Direct vendor SDK imports outside the wrapper packages
   (`import 'stripe'` outside `@working-theory/stripe-client`, etc.).

package/templates/.claude/skills/README.md

@@ -6,22 +6,22 @@ it and how it works.
 
 The seven OSS skills below are the canonical AI Launch Kit workflows.
 Their status reflects what's available at the upstream
-<https://github.com/tailwind-ai/ai-launch-kit> repository today. Issue
+<https://github.com/working-theory-labs/ai-launch-kit> repository today. Issue
 numbers in the table refer to that upstream repo (the
-`tailwind-ai/ai-launch-kit#N` form makes the link explicit), not your
+`working-theory-labs/ai-launch-kit#N` form makes the link explicit), not your
 local project's issues.
 
 ## Status
 
 | Skill                | Purpose                                                | Status                                               |
 | -------------------- | ------------------------------------------------------ | ---------------------------------------------------- |
-| `suggest-site-pages` | Generic page-type suggestions by category              | coming soon — issue #361 (tailwind-ai/ai-launch-kit) |
-| `scaffold-page`      | Generate a page with the appropriate schema.org type   | coming soon — issue #362 (tailwind-ai/ai-launch-kit) |
-| `scaffold-commerce`  | Sell stuff: external store link or direct payments     | coming soon — issue #363 (tailwind-ai/ai-launch-kit) |
-| `scaffold-auth`      | Wire up an auth flow against `@working-theory/auth-client`       | coming soon — issue #364 (tailwind-ai/ai-launch-kit) |
-| `audit-site`         | Run `ailk audit` and explain the results               | coming soon — issue #365 (tailwind-ai/ai-launch-kit) |
-| `add-schema`         | Add Product / Service / FAQ schema to an existing page | coming soon — issue #366 (tailwind-ai/ai-launch-kit) |
-| `provision-config`   | Generate `vercel.json` and environment templates       | coming soon — issue #367 (tailwind-ai/ai-launch-kit) |
+| `suggest-site-pages` | Generic page-type suggestions by category              | coming soon — issue #361 (working-theory-labs/ai-launch-kit) |
+| `scaffold-page`      | Generate a page with the appropriate schema.org type   | coming soon — issue #362 (working-theory-labs/ai-launch-kit) |
+| `scaffold-commerce`  | Sell stuff: external store link or direct payments     | coming soon — issue #363 (working-theory-labs/ai-launch-kit) |
+| `scaffold-auth`      | Wire up an auth flow against `@working-theory/auth-client`       | coming soon — issue #364 (working-theory-labs/ai-launch-kit) |
+| `audit-site`         | Run `ailk audit` and explain the results               | coming soon — issue #365 (working-theory-labs/ai-launch-kit) |
+| `add-schema`         | Add Product / Service / FAQ schema to an existing page | coming soon — issue #366 (working-theory-labs/ai-launch-kit) |
+| `provision-config`   | Generate `vercel.json` and environment templates       | coming soon — issue #367 (working-theory-labs/ai-launch-kit) |
 
 ## How a skill ships
 

package/templates/.claude/skills/add-schema/SKILL.md

@@ -170,8 +170,13 @@ new builder if not already imported.
 
 ### Step 6 — Type-aware classification
 
-`references/schema-types.md` tags each of the 45 schema.org types
-in `@working-theory/schema` as **primary** or **supplementary**:
+`references/schema-types.md` tags the general schema.org vocabulary
+it curates as **primary** or **supplementary**; the AILK page-type
+registry (60 keys, all builder-backed in `@working-theory/schema`) is
+listed separately in that file's "AILK page types" section and is
+treated as **primary** for conflict handling — a registry page type
+names what the whole page IS about, and replacing on same-type
+conflict is the usual intent:
 
 - **Primary** types are typically one-per-page: `HomePage`,
   `AboutPage`, `BlogPosting`, `Product`, `Service`. A page rarely
@@ -235,22 +240,24 @@ If parse succeeds, print a closing summary:
 
 ## Type-by-name recognition
 
-The skill recognizes all 45 schema types in `@working-theory/schema` by name.
+The skill recognizes all 60 AILK page types in `@working-theory/schema` by
+name, plus a smaller general schema.org vocabulary for non-registry types.
 Common aliases (e.g., "FAQ" → `FAQPage`, "how-to" → `HowTo`,
 "review" → `Review`) are handled in `references/schema-types.md`.
 If the consumer asks for a type not in the catalog, surface and
 ask:
 
-> "I don't see `<requested type>` in the v1 schema catalog. The 45
+> "I don't see `<requested type>` in the v1 schema catalog. The
 > recognized types are listed in `references/schema-types.md` —
 > closest matches are `<X>` and `<Y>`. Use one of those, or hand-
 > author the JSON-LD inline if you need a less-common type."
 
 ## References
 
-- `references/schema-types.md` — the 45 schema.org types from
-  `@working-theory/schema`, each tagged primary or supplementary, with
-  human-friendly aliases.
+- `references/schema-types.md` — the 60 registry-backed AILK page types
+  from `@working-theory/schema`, plus a smaller general schema.org
+  vocabulary tagged primary or supplementary, with human-friendly
+  aliases.
 - `references/file-finding.md` — slug-to-file resolution rules
   (App Router + MDX).
 - `references/conflict-handling.md` — full decision tree for

package/templates/.claude/skills/add-schema/references/schema-types.md

@@ -100,14 +100,117 @@ these by name; conflict handling defaults to **supplementary**
 | `ScholarlyArticle`                  | _consumer-defined_ | "scholarly article", "paper"     |
 | `LegislativeBuilding`               | _consumer-defined_ | _rare, government use_           |
 
+## AILK page types (registry-backed — 60 keys, one builder each)
+
+Every key below is an entry in `@working-theory/schema`'s page-type registry
+(`packages/schema/src/registry/entries.ts`) and has a real, exported builder
+reachable via `buildJsonLd({ type: '<Key>', ... })` — this is the complete
+list of scaffoldable AILK page types, as opposed to the smaller general
+schema.org vocabulary tables above (some of which is still
+`_consumer-defined_`, i.e. not yet builder-backed). Several keys share one
+`@type` (e.g. `PrivacyPage` / `TermsPage` / `LandingPage` / `ThankYouPage` all
+emit `WebPage`) — the registry has 60 entries but only 24 distinct `@type`
+values. Re-derive with `pnpm page-type-counts`
+(`scripts/component/page-type-counts.ts` in the `ai-launch-kit-internal`
+source repo) before hand-editing this table.
+
+### Core (15)
+
+| Key | `@type` |
+| --- | --- |
+| `HomePage` | `HomePage` |
+| `AboutPage` | `AboutPage` |
+| `ContactPage` | `ContactPage` |
+| `PrivacyPage` | `WebPage` |
+| `TermsPage` | `WebPage` |
+| `LandingPage` | `WebPage` |
+| `ThankYouPage` | `WebPage` |
+| `BookCall` | `WebPage` |
+| `NewsletterSignup` | `WebPage` |
+| `DemoRequest` | `WebPage` |
+| `TrialSignup` | `WebPage` |
+| `Waitlist` | `WebPage` |
+| `Assessment` | `WebApplication` |
+| `Calculator` | `WebApplication` |
+| `CampaignLP` | `WebPage` |
+
+### Identity (4)
+
+`Organization` / `Person` / `BreadcrumbList` / `ContactPoint` — see the
+[Identity types](#identity-types-one-site-wide-emit-on-home-or-in-layout)
+table above; all four are registry-backed.
+
+### Canonical-List (17)
+
+| Key | `@type` |
+| --- | --- |
+| `ServicesList` | `CollectionPage` |
+| `ProductsList` | `CollectionPage` |
+| `ProjectsList` | `CollectionPage` |
+| `FAQPage` | `FAQPage` |
+| `CareersList` | `CollectionPage` |
+| `UseCasesList` | `CollectionPage` |
+| `TestimonialsList` | `CollectionPage` |
+| `ClientsList` | `CollectionPage` |
+| `DownloadsList` | `CollectionPage` |
+| `EventsList` | `CollectionPage` |
+| `CoursesList` | `CollectionPage` |
+| `TeamList` | `CollectionPage` |
+| `PartnersList` | `CollectionPage` |
+| `IntegrationsList` | `CollectionPage` |
+| `GlossaryList` | `CollectionPage` |
+| `LocationsList` | `CollectionPage` |
+| `DocsList` | `CollectionPage` |
+
+### Canonical-Detail (14)
+
+| Key | `@type` |
+| --- | --- |
+| `Service` | `Service` |
+| `Product` | `Product` |
+| `Project` | `CreativeWork` |
+| `Event` | `Event` |
+| `Course` | `Course` |
+| `TeamMember` | `ProfilePage` |
+| `Partner` | `AboutPage` |
+| `Integration` | `WebPage` |
+| `JobPosting` | `JobPosting` |
+| `SoftwareProduct` | `WebPage` |
+| `Location` | `Place` |
+| `ServiceAreaPage` | `WebPage` |
+| `UseCase` | `WebPage` |
+| `Pricing` | `WebPage` |
+
+### Editorial-List (3)
+
+| Key | `@type` |
+| --- | --- |
+| `BlogList` | `Blog` |
+| `ResourcesHub` | `CollectionPage` |
+| `CaseStudiesList` | `CollectionPage` |
+
+### Editorial-Detail (7)
+
+| Key | `@type` |
+| --- | --- |
+| `BlogPosting` | `BlogPosting` |
+| `CaseStudy` | `Article` |
+| `HowTo` | `HowTo` |
+| `Whitepaper` | `Article` |
+| `ResourceDetail` | `Article` |
+| `TechArticle` | `TechArticle` |
+| `DocsDetail` | `TechArticle` |
+
 ## Total
 
-This catalog covers approximately **45 types** total — matching the
-brief's "all 45 schema types from `@working-theory/schema`" claim. Some
-builders are still `_consumer-defined_` because `@working-theory/schema`
-hasn't shipped a typed builder yet — for those, the skill emits
-the JSON-LD as an inline literal with a comment noting the
-upstream issue.
+**Two distinct counts, not one.** The AILK page-type registry — the types
+`add-schema` can scaffold with a real builder — has **60 keys** (24 distinct
+`@type` values; see the family tables above). The general schema.org
+vocabulary tables earlier in this file are a separate, smaller, hand-curated
+list the skill also recognizes by name for non-registry types; several of
+those are still `_consumer-defined_` because `@working-theory/schema` hasn't
+shipped a typed builder for them yet — for those, the skill emits the JSON-LD
+as an inline literal with a comment noting the upstream issue.
 
 ## When `@working-theory/schema` doesn't yet export the builder
 

package/templates/.claude/skills/provision-config/SKILL.md

@@ -66,7 +66,7 @@ platform, respond:
 
 > "`provision-config` is Vercel-only at v1. Netlify / Cloudflare /
 > Render / Fly / self-host support are tracked at the upstream repo —
-> file an issue at <https://github.com/tailwind-ai/ai-launch-kit/issues>
+> file an issue at <https://github.com/working-theory-labs/ai-launch-kit/issues>
 > if your platform is missing.
 >
 > Cloudflare is deferred entirely (deploy target + KV/D1/R2 data