@valbuild/shared 0.124.0 → 0.126.0

package/CHANGELOG.md

@@ -1,5 +1,215 @@
 # @valbuild/shared
 
+## 0.126.0
+
+### Minor Changes
+
+- [#652](https://github.com/valbuild/val/pull/652) [`f2fe70d`](https://github.com/valbuild/val/commit/f2fe70dab2b65000dfaf289f09c70b4a8291467a) Thanks [@freekh](https://github.com/freekh)! - `s.union` is now `s.discriminatedUnion` and `s.enum`.
+
+  `s.union` did two unrelated jobs and worked out which one you meant from its
+  first argument: a string key meant a tagged union of objects, literal schemas
+  meant a set of allowed strings. Those are now two schemas with two names.
+
+  ```ts
+  // A fixed set of strings — presents as a dropdown
+  s.enum("primary", "secondary", "ghost"); // Schema<"primary" | "secondary" | "ghost">
+
+  // One of several object shapes, told apart by a tag field
+  s.discriminatedUnion(
+    "type",
+    s.object({ type: s.literal("hero"), heading: s.string() }),
+    s.object({ type: s.literal("quote"), text: s.string() }),
+  );
+  ```
+
+  `s.enum` takes the strings directly, so the `s.literal(...)` wrapper is gone.
+
+  **`s.union` still works** — it is deprecated, and it builds exactly the schema
+  above, so nothing has to change today:
+
+  ```ts
+  s.union(s.literal("one"), s.literal("two")); // → s.enum("one", "two")
+  s.union("type", pageA, pageB); // → s.discriminatedUnion("type", pageA, pageB)
+  ```
+
+  The two are different kinds of node, and that is the reason for the split. A
+  discriminated union is a container: the selected variant's fields are the fields
+  being edited, and everything that walks a schema descends through it. An enum is
+  a leaf — a string with a closed domain — so nothing recurses into it. Told apart
+  only by the shape of `key`, every consumer had to re-derive which one it was
+  holding; each now has its own serialized type (`"discriminated-union"` and
+  `"enum"`) and Val Studio has a field per kind rather than one field that
+  branches.
+
+  Two behaviour changes fall out of the split, both of them fixes:
+
+  - A value that is not a string at all now fails an enum's validation with a
+    type error. `s.union` of literals only ever checked the value against its
+    literals when the value WAS a string, so a number or an object where an enum
+    was declared validated clean.
+  - An enum field now shows its validation errors in Val Studio where the field
+    is opened on its own — the module editor and the canvas's fields column — and
+    gets the compact error layout inside an inline list row. It is a leaf now, so
+    it goes through the same error rendering as every other leaf field; the string
+    union bypassed it and showed nothing in those places.
+
+  Several latent crashes in the old `s.union` are fixed on the way past, all of
+  them cases where it threw a `TypeError` instead of reporting:
+
+  - A required discriminated union holding `null` now reports a type error rather
+    than throwing, and resolving a path underneath a nullable one that is `null`
+    gives the error the API promises instead of a crash.
+  - `s.literal("")` is a legal discriminator tag, and `s.enum("")` a legal value.
+    Both used to be treated as absent by a truthiness check — in path resolution,
+    in stega encoding, and in the message that lists a union's valid tags. The
+    editor's dropdowns handle them too: an empty value is reserved by the select
+    component and had to be mapped around.
+  - A variant that omits the discriminator entirely is now reported as the schema
+    error it is, instead of throwing while the check looked for it.
+  - An enum's value is now indexed for search, like every other string leaf. The
+    old string union was never indexed at all, so searching for one of its values
+    could not find the field.
+  - A nullable discriminated union set to `null` no longer renders a spinner that
+    never resolves.
+
+  `s.discriminatedUnion` also requires at least one variant, as `s.enum` requires
+  at least one value: a union with nothing to select is not a thing to write, and
+  everything downstream reads the first variant where it needs any.
+
+  If you read serialized schemas yourself, that is the breaking part: `type` is no
+  longer `"union"`, an enum carries `values: string[]` instead of a `key` plus
+  `items` of literal schemas, and `UnionSchema` is no longer a class.
+  `SerializedUnionSchema`, `SerializedStringUnionSchema`,
+  `SerializedObjectUnionSchema` and `UnionSchema` remain as deprecated type
+  aliases.
+
+### Patch Changes
+
+- [#664](https://github.com/valbuild/val/pull/664) [`5bfd630`](https://github.com/valbuild/val/commit/5bfd630b63dee2189e238f20fe72ecc5537160f7) Thanks [@freekh](https://github.com/freekh)! - Show the git message on deployments Val did not publish
+
+  The deploy feed could only name a publish when Val itself had made the commit:
+  the message came off Val's own `ValCommit`, and every other deployment — a
+  developer's push, a merged pull request, a revert — showed a seven-character
+  sha. On most projects those are the majority, so "what went out at 14:02?" had
+  no answer in the Studio.
+
+  A deployment can now carry its own `commitMessage`, which the Studio uses
+  wherever there is no Val commit to prefer. It is optional and nullable, so a
+  content service that does not report messages is unaffected — those publishes
+  keep showing the short sha, exactly as before.
+
+  Deployment rows also show only the subject line of a message now. A git message
+  is a subject, a blank line and a body, and the rows are one truncated line — so
+  a real push arrived as "Subject The body went on like this…". The classic
+  Draft changes view still has the whole message in its tooltip.
+
+- [#659](https://github.com/valbuild/val/pull/659) [`ccbcda6`](https://github.com/valbuild/val/commit/ccbcda60b3e3c465071229ae1ba28ac735483e63) Thanks [@freekh](https://github.com/freekh)! - Discarding changes now clears the validation errors, previews and search results
+  that were computed from them.
+
+  A discard that removed a module's last pending change announced itself only as
+  a "drop", and the stores that keep validation results, previews and the search
+  index listened only for changes being applied. So after discarding, the Studio
+  kept showing the errors and previews of the discarded edit until something else
+  touched the module.
+
+  Fields that reference another module's keys (`s.keyOf(...)` and `s.route()`)
+  also follow that module now. Renaming a page and then discarding the rename left
+  every `keyOf` field pointing at it reporting that the key does not exist — about
+  a key that was back — because the module holding the reference had not changed
+  and was never re-checked. The validation store now tracks which records a
+  module's errors resolve against and re-checks it when their keys change, and only
+  then: editing content inside a referenced page does not re-validate its
+  referrers.
+
+- Updated dependencies [[`f2fe70d`](https://github.com/valbuild/val/commit/f2fe70dab2b65000dfaf289f09c70b4a8291467a), [`171208a`](https://github.com/valbuild/val/commit/171208a20177e68ed5a8b1a6fdaabfe893a6aa5f)]:
+  - @valbuild/core@0.126.0
+
+## 0.125.0
+
+### Minor Changes
+
+- [#638](https://github.com/valbuild/val/pull/638) [`c390397`](https://github.com/valbuild/val/commit/c390397cb5e203eb1bedae3a6fab15726e850b90) Thanks [@freekh](https://github.com/freekh)! - Val now runs on TanStack Start.
+
+  `@valbuild/tanstack` is a new package with everything `@valbuild/next` has: Val
+  Studio at `/val`, the on-page overlay and canvas, draft mode, the client hooks,
+  server-side content reads, images, and the MCP tools.
+
+  ```sh
+  npm install @valbuild/tanstack
+  ```
+
+  ```ts
+  // val.config.ts
+  import { initVal } from "@valbuild/tanstack";
+  const { s, c, config, tanstackRouter } = initVal({ project: "org/project" });
+  ```
+
+  **Routes are first class.** A Val module for a route is named after the route
+  file it sits beside — `src/routes/posts.$postId.tsx` is served content by
+  `src/routes/posts.$postId.val.ts` — and its keys are the URLs that route serves:
+
+  ```ts
+  export default c.define(
+    "/src/routes/posts.$postId.val.ts",
+    s.router(tanstackRouter, s.object({ title: s.string() })),
+    { "/posts/hello-world": { title: "Hello world" } },
+  );
+  ```
+
+  `.` and `/` both separate segments, `$param` is a parameter, `$` is a splat, and
+  `index`, `route`, `(groups)` and `_pathless` layouts add no URL segment — the
+  same rules TanStack Router uses for the route file itself. Val validates every
+  key against that pattern, and Val Studio shows these modules as a sitemap under
+  **Pages**, where an editor can add a page.
+
+  Point the route generator away from your content files, in `vite.config.ts` and
+  `tsr.config.json`:
+
+  ```ts
+  tanstackStart({ router: { routeFileIgnorePattern: "\\.val\\.[tj]sx?$" } });
+  ```
+
+  See the [README](https://github.com/valbuild/val/blob/main/packages/tanstack/README.md)
+  for the full wiring, and `examples/tanstack` for a working app.
+
+  **Also fixed, for everyone:** `Internal.VERSION.core` was `null` in any ESM
+  bundle — it was read with `require("../package.json")` inside a `try`, so the
+  failure was silent. That version goes into every remote file ref and proxy mode
+  refuses to start without it. Every package now reads its version through a
+  static JSON import, which is inlined at build time.
+
+  Two smaller fixes that came out of running the whole toolchain against a
+  TanStack project:
+
+  - `val versions` reports `@valbuild/tanstack`, and `val debug` writes a snapshot
+    that names whichever framework package the captured project actually has.
+  - `@valbuild/eslint-plugin` reads a `tsconfig.json` that has comments in it. A
+    tsconfig is JSONC, and `JSON.parse` is not — so on any project whose tsconfig
+    carries a comment (the TanStack starter's does) the
+    `module-in-val-modules` rule threw `Expected double-quoted property name in
+JSON` on the first file and took the whole lint run with it.
+
+  Three fixes found by driving the Studio against a real TanStack app:
+
+  - **A draft image now loads on the page.** The source the Studio pushes to the
+    host page carries `patch_id` for any file whose bytes are still in a patch, so
+    the page asks `/api/val/files/...?patch_id=` rather than a `/public` path that
+    nothing has written yet. This was silent — the image just did not appear — and
+    it affects any page that reads media through the hooks rather than on the
+    server, `@valbuild/next` included.
+  - **A splat route no longer logs an error on every render.** TanStack returns
+    both `_splat` and `*` for the same parameter; Val reported the second as a
+    parameter it could not place in the path.
+  - The TanStack example and starter render a 404 page instead of throwing
+    `notFound()` from a component, which escaped to the error boundary and logged
+    `Error in renderToReadableStream` (and, with no not-found component
+    configured, aborted the response) on every miss.
+
+### Patch Changes
+
+- Updated dependencies [[`c390397`](https://github.com/valbuild/val/commit/c390397cb5e203eb1bedae3a6fab15726e850b90)]:
+  - @valbuild/core@0.125.0
+
 ## 0.124.0
 
 ### Minor Changes

package/client/dist/valbuild-shared-client.cjs.dev.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var getSitemapTree = require('../../dist/getSitemapTree-a0c9a0e3.cjs.dev.js');
+var getSitemapTree = require('../../dist/getSitemapTree-d1977d3e.cjs.dev.js');
 require('@valbuild/core');
 
 
@@ -12,9 +12,12 @@ exports.VAL_CANVAS_MESSAGE = getSitemapTree.VAL_CANVAS_MESSAGE;
 exports.VAL_CANVAS_PARAM = getSitemapTree.VAL_CANVAS_PARAM;
 exports.VAL_CONFIG_SESSION_STORAGE_KEY = getSitemapTree.VAL_CONFIG_SESSION_STORAGE_KEY;
 exports.VAL_THEME_SESSION_STORAGE_KEY = getSitemapTree.VAL_THEME_SESSION_STORAGE_KEY;
-exports.getNextAppRouterSitemapTree = getSitemapTree.getNextAppRouterSitemapTree;
 exports.getNextAppRouterSourceFolder = getSitemapTree.getNextAppRouterSourceFolder;
+exports.getPageRouterSitemapTree = getSitemapTree.getPageRouterSitemapTree;
+exports.getPageRouterSourceFolder = getSitemapTree.getPageRouterSourceFolder;
 exports.getPatternFromModuleFilePath = getSitemapTree.getPatternFromModuleFilePath;
+exports.getTanStackRouterSourceFolder = getSitemapTree.getTanStackRouterSourceFolder;
+exports.isTanStackRoutesFolder = getSitemapTree.isTanStackRoutesFolder;
 exports.isValCanvasFrame = getSitemapTree.isValCanvasFrame;
 exports.isValCanvasPageMessage = getSitemapTree.isValCanvasPageMessage;
 exports.isValCanvasStudioMessage = getSitemapTree.isValCanvasStudioMessage;

package/client/dist/valbuild-shared-client.cjs.prod.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var getSitemapTree = require('../../dist/getSitemapTree-77b1203a.cjs.prod.js');
+var getSitemapTree = require('../../dist/getSitemapTree-b320d033.cjs.prod.js');
 require('@valbuild/core');
 
 
@@ -12,9 +12,12 @@ exports.VAL_CANVAS_MESSAGE = getSitemapTree.VAL_CANVAS_MESSAGE;
 exports.VAL_CANVAS_PARAM = getSitemapTree.VAL_CANVAS_PARAM;
 exports.VAL_CONFIG_SESSION_STORAGE_KEY = getSitemapTree.VAL_CONFIG_SESSION_STORAGE_KEY;
 exports.VAL_THEME_SESSION_STORAGE_KEY = getSitemapTree.VAL_THEME_SESSION_STORAGE_KEY;
-exports.getNextAppRouterSitemapTree = getSitemapTree.getNextAppRouterSitemapTree;
 exports.getNextAppRouterSourceFolder = getSitemapTree.getNextAppRouterSourceFolder;
+exports.getPageRouterSitemapTree = getSitemapTree.getPageRouterSitemapTree;
+exports.getPageRouterSourceFolder = getSitemapTree.getPageRouterSourceFolder;
 exports.getPatternFromModuleFilePath = getSitemapTree.getPatternFromModuleFilePath;
+exports.getTanStackRouterSourceFolder = getSitemapTree.getTanStackRouterSourceFolder;
+exports.isTanStackRoutesFolder = getSitemapTree.isTanStackRoutesFolder;
 exports.isValCanvasFrame = getSitemapTree.isValCanvasFrame;
 exports.isValCanvasPageMessage = getSitemapTree.isValCanvasPageMessage;
 exports.isValCanvasStudioMessage = getSitemapTree.isValCanvasStudioMessage;

package/client/dist/valbuild-shared-client.esm.js

@@ -1,2 +1,2 @@
-export { b as VAL_AI_SESSION_STORAGE_KEY, d as VAL_CANVAS_MESSAGE, c as VAL_CANVAS_PARAM, V as VAL_CONFIG_SESSION_STORAGE_KEY, a as VAL_THEME_SESSION_STORAGE_KEY, h as getNextAppRouterSitemapTree, g as getNextAppRouterSourceFolder, j as getPatternFromModuleFilePath, f as isValCanvasFrame, i as isValCanvasPageMessage, e as isValCanvasStudioMessage, p as parseRoutePattern, w as withValCanvasParam } from '../../dist/getSitemapTree-d3e98a2e.esm.js';
+export { b as VAL_AI_SESSION_STORAGE_KEY, d as VAL_CANVAS_MESSAGE, c as VAL_CANVAS_PARAM, V as VAL_CONFIG_SESSION_STORAGE_KEY, a as VAL_THEME_SESSION_STORAGE_KEY, g as getNextAppRouterSourceFolder, l as getPageRouterSitemapTree, j as getPageRouterSourceFolder, m as getPatternFromModuleFilePath, h as getTanStackRouterSourceFolder, k as isTanStackRoutesFolder, f as isValCanvasFrame, i as isValCanvasPageMessage, e as isValCanvasStudioMessage, p as parseRoutePattern, w as withValCanvasParam } from '../../dist/getSitemapTree-a6cb37cb.esm.js';
 import '@valbuild/core';

package/dist/declarations/src/internal/ApiRoutes.d.ts

@@ -443,6 +443,14 @@ export declare const Api: {
                         createdAt: z.ZodString;
                         commitMessage: z.ZodNullable<z.ZodString>;
                     }, z.core.$strip>>;
+                    deployments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        deploymentId: z.ZodString;
+                        deploymentState: z.ZodString;
+                        commitSha: z.ZodString;
+                        updatedAt: z.ZodString;
+                        createdAt: z.ZodString;
+                        commitMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>>;
                     config: z.ZodObject<{
                         project: z.ZodOptional<z.ZodString>;
                         root: z.ZodOptional<z.ZodString>;

package/dist/declarations/src/internal/getNextAppRouterSourceFolder.d.ts

@@ -1,2 +1,26 @@
 import { ModuleFilePath } from "@valbuild/core";
 export declare function getNextAppRouterSourceFolder(moduleFilePath: ModuleFilePath): "/app" | "/src/app" | null;
+/**
+ * The folder a TanStack Router app keeps its route files in.
+ *
+ * The same question as above for the other convention: `routes/` at the project
+ * root, or under `src/`. A Val module for a route lives beside the route file
+ * and is named the same way, so this is the prefix to strip before reading the
+ * route pattern out of the rest.
+ */
+export declare function getTanStackRouterSourceFolder(moduleFilePath: ModuleFilePath): "/routes" | "/src/routes" | null;
+/**
+ * The route folder of whichever page router this module belongs to.
+ *
+ * The two conventions have disjoint prefixes — `app/` versus `routes/` — so a
+ * module file path answers this on its own, which is what the Studio needs: it
+ * walks every schema in the project and has no framework to ask.
+ */
+export declare function getPageRouterSourceFolder(moduleFilePath: ModuleFilePath): "/app" | "/src/app" | "/routes" | "/src/routes" | null;
+/**
+ * Whether a route folder is a TanStack Router one.
+ *
+ * Exported so the pattern derivation and the source-folder detection cannot
+ * drift apart about what `/src/routes` means.
+ */
+export declare function isTanStackRoutesFolder(srcFolder: string): boolean;

package/dist/declarations/src/internal/getSitemapTree.d.ts

@@ -23,8 +23,17 @@ export type SitemapNode = {
     moduleFilePath?: ModuleFilePath;
     sourcePath?: SourcePath | ModuleFilePath;
 };
-export declare function getNextAppRouterSitemapTree(srcFolder: string, paths: {
+export declare function getPageRouterSitemapTree(srcFolder: string, paths: {
     urlPath: string;
     moduleFilePath: string;
 }[]): SitemapNode;
+/**
+ * The route pattern a page-router module serves, e.g. `/blogs/[blog]`.
+ *
+ * Written in Next's vocabulary for both routers on purpose: the pattern is read
+ * by `parseRoutePattern`, the sitemap and the Studio's key inputs, none of which
+ * should have to know which framework the project uses. The TanStack branch
+ * translates that framework's conventions into it; see
+ * `tanStackSegmentsOfRoutePath` in `@valbuild/core` for the rules.
+ */
 export declare function getPatternFromModuleFilePath(moduleFilePath: string, srcFolder: string): string;

package/dist/declarations/src/internal/resolveSchemaSourceFixes.d.ts

@@ -14,12 +14,37 @@ export declare function findSimilar(key: string, targets: string[]): {
     target: string;
     distance: number;
 }[];
+/**
+ * The record a `keyof:check-keys` error resolves against — the value and the
+ * schema at the error's `sourcePath`.
+ *
+ * Exported for the one consumer that has to know what a resolution DEPENDED
+ * on rather than what it concluded: `ValidationStore` re-reads the keys here
+ * to decide whether a change to the referenced module can have moved the
+ * answer. Keep this and {@link checkKeyIsValid} reading the same record, or the
+ * store will invalidate on one record and the resolution answer from another.
+ */
+export declare function getKeyOfRecordAt(sourcePath: SourcePath, snapshot: SchemaSourceSnapshot): {
+    source: unknown;
+    schema: SerializedSchema | undefined;
+};
 export type ResolvedFix = {
     status: "resolved";
 } | {
     status: "remaining";
     error: ValidationError;
 };
+/**
+ * The record a `keyof:check-keys` error resolves against, or null for any other
+ * error — including a malformed marker, which
+ * {@link resolveSchemaSourceFixForError} reports and this has nothing to say
+ * about.
+ *
+ * For a consumer that needs to know what the resolution READS, not what it
+ * concludes: `ValidationStore` keeps this per validated module, so that a change
+ * to the referenced record can invalidate the module holding the reference.
+ */
+export declare function keyOfRecordPath(error: ValidationError): SourcePath | null;
 /**
  * Resolves a single `keyof:check-keys` or `router:check-route` error against
  * the given schema/source snapshot. Returns:

package/dist/declarations/src/internal/zod/SerializedSchema.d.ts

@@ -1,12 +1,13 @@
 import { z } from "zod";
-import { type SerializedSchema as SerializedSchemaT, type SerializedStringSchema as SerializedStringSchemaT, type SerializedLiteralSchema as SerializedLiteralSchemaT, type SerializedBooleanSchema as SerializedBooleanSchemaT, type SerializedNumberSchema as SerializedNumberSchemaT, type SerializedObjectSchema as SerializedObjectSchemaT, type SerializedArraySchema as SerializedArraySchemaT, type SerializedUnionSchema as SerializedUnionSchemaT, type SerializedRichTextSchema as SerializedRichTextSchemaT, type SerializedRichTextOptions as SerializedRichTextOptionsT, type SerializedRecordSchema as SerializedRecordSchemaT, type SerializedKeyOfSchema as SerializedKeyOfSchemaT, type SerializedRouteSchema as SerializedRouteSchemaT, type SerializedFileSchema as SerializedFileSchemaT, type SerializedDateSchema as SerializedDateSchemaT, type SerializedDateTimeSchema as SerializedDateTimeSchemaT, type SerializedColorSchema as SerializedColorSchemaT, type SerializedCodeSchema as SerializedCodeSchemaT, type SerializedImageSchema as SerializedImageSchemaT, type SerializedSettingsSchema as SerializedSettingsSchemaT } from "@valbuild/core";
+import { type SerializedSchema as SerializedSchemaT, type SerializedStringSchema as SerializedStringSchemaT, type SerializedLiteralSchema as SerializedLiteralSchemaT, type SerializedBooleanSchema as SerializedBooleanSchemaT, type SerializedNumberSchema as SerializedNumberSchemaT, type SerializedObjectSchema as SerializedObjectSchemaT, type SerializedArraySchema as SerializedArraySchemaT, type SerializedDiscriminatedUnionSchema as SerializedDiscriminatedUnionSchemaT, type SerializedEnumSchema as SerializedEnumSchemaT, type SerializedRichTextSchema as SerializedRichTextSchemaT, type SerializedRichTextOptions as SerializedRichTextOptionsT, type SerializedRecordSchema as SerializedRecordSchemaT, type SerializedKeyOfSchema as SerializedKeyOfSchemaT, type SerializedRouteSchema as SerializedRouteSchemaT, type SerializedFileSchema as SerializedFileSchemaT, type SerializedDateSchema as SerializedDateSchemaT, type SerializedDateTimeSchema as SerializedDateTimeSchemaT, type SerializedColorSchema as SerializedColorSchemaT, type SerializedCodeSchema as SerializedCodeSchemaT, type SerializedImageSchema as SerializedImageSchemaT, type SerializedSettingsSchema as SerializedSettingsSchemaT } from "@valbuild/core";
 export declare const SerializedStringSchema: z.ZodType<SerializedStringSchemaT>;
 export declare const SerializedLiteralSchema: z.ZodType<SerializedLiteralSchemaT>;
 export declare const SerializedBooleanSchema: z.ZodType<SerializedBooleanSchemaT>;
 export declare const SerializedNumberSchema: z.ZodType<SerializedNumberSchemaT>;
 export declare const SerializedObjectSchema: z.ZodType<SerializedObjectSchemaT>;
 export declare const SerializedArraySchema: z.ZodType<SerializedArraySchemaT>;
-export declare const SerializedUnionSchema: z.ZodType<SerializedUnionSchemaT>;
+export declare const SerializedDiscriminatedUnionSchema: z.ZodType<SerializedDiscriminatedUnionSchemaT>;
+export declare const SerializedEnumSchema: z.ZodType<SerializedEnumSchemaT>;
 export declare const ImageEncodeOption: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
     type: z.ZodLiteral<"webp">;
     quality: z.ZodOptional<z.ZodNumber>;

package/dist/declarations/src/internal/zod/ValDeployment.d.ts

@@ -5,5 +5,6 @@ export declare const ValDeployment: z.ZodObject<{
     commitSha: z.ZodString;
     updatedAt: z.ZodString;
     createdAt: z.ZodString;
+    commitMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export type ValDeployment = z.infer<typeof ValDeployment>;

package/dist/{getSitemapTree-d3e98a2e.esm.js → getSitemapTree-a6cb37cb.esm.js}

@@ -1,4 +1,4 @@
-import { Internal } from '@valbuild/core';
+import { Internal, tanStackSegmentsOfRoutePath } from '@valbuild/core';
 
 var VAL_CONFIG_SESSION_STORAGE_KEY = "val-config";
 var VAL_THEME_SESSION_STORAGE_KEY = "val-theme";
@@ -135,6 +135,45 @@ function getNextAppRouterSourceFolder(moduleFilePath) {
   return null;
 }
 
+/**
+ * The folder a TanStack Router app keeps its route files in.
+ *
+ * The same question as above for the other convention: `routes/` at the project
+ * root, or under `src/`. A Val module for a route lives beside the route file
+ * and is named the same way, so this is the prefix to strip before reading the
+ * route pattern out of the rest.
+ */
+function getTanStackRouterSourceFolder(moduleFilePath) {
+  if (moduleFilePath.startsWith("/routes/")) {
+    return "/routes";
+  } else if (moduleFilePath.startsWith("/src/routes/")) {
+    return "/src/routes";
+  }
+  return null;
+}
+
+/**
+ * The route folder of whichever page router this module belongs to.
+ *
+ * The two conventions have disjoint prefixes — `app/` versus `routes/` — so a
+ * module file path answers this on its own, which is what the Studio needs: it
+ * walks every schema in the project and has no framework to ask.
+ */
+function getPageRouterSourceFolder(moduleFilePath) {
+  var _getNextAppRouterSour;
+  return (_getNextAppRouterSour = getNextAppRouterSourceFolder(moduleFilePath)) !== null && _getNextAppRouterSour !== void 0 ? _getNextAppRouterSour : getTanStackRouterSourceFolder(moduleFilePath);
+}
+
+/**
+ * Whether a route folder is a TanStack Router one.
+ *
+ * Exported so the pattern derivation and the source-folder detection cannot
+ * drift apart about what `/src/routes` means.
+ */
+function isTanStackRoutesFolder(srcFolder) {
+  return srcFolder === "/routes" || srcFolder === "/src/routes";
+}
+
 function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
@@ -245,8 +284,14 @@ function _createForOfIteratorHelper(r, e) {
   };
 }
 
-// Strictly speaking this should be in the next package but it's shared, because we want to use it in the ui package. We want to resolve that somehow
-function getNextAppRouterSitemapTree(srcFolder, paths) {
+// Strictly speaking this should be in the framework packages but it's shared,
+// because we want to use it in the ui package. We want to resolve that somehow.
+//
+// It is one function for both page routers because the tree it builds is made
+// of URL paths, which is the same thing in either: only `srcFolder` and the
+// pattern derivation differ, and both of those are arguments (or the one call
+// below).
+function getPageRouterSitemapTree(srcFolder, paths) {
   var root = {
     type: "node",
     name: "/",
@@ -358,7 +403,24 @@ function getNextAppRouterSitemapTree(srcFolder, paths) {
   }
   return root;
 }
+
+/**
+ * The route pattern a page-router module serves, e.g. `/blogs/[blog]`.
+ *
+ * Written in Next's vocabulary for both routers on purpose: the pattern is read
+ * by `parseRoutePattern`, the sitemap and the Studio's key inputs, none of which
+ * should have to know which framework the project uses. The TanStack branch
+ * translates that framework's conventions into it; see
+ * `tanStackSegmentsOfRoutePath` in `@valbuild/core` for the rules.
+ */
 function getPatternFromModuleFilePath(moduleFilePath, srcFolder) {
+  if (isTanStackRoutesFolder(srcFolder)) {
+    var routePath = moduleFilePath.slice(srcFolder.length).replace(/\.val\.[tj]sx?$/, "");
+    var segments = tanStackSegmentsOfRoutePath(routePath);
+    // "" rather than "/" for the root, so it matches what the Next branch
+    // returns for `/app/page.val.ts` — `parseRoutePattern` reads both as [].
+    return segments.length === 0 ? "" : "/".concat(segments.join("/"));
+  }
   return moduleFilePath.replace(srcFolder, "")
   // TODO: hacky!
   // remove route groups
@@ -366,4 +428,4 @@ function getPatternFromModuleFilePath(moduleFilePath, srcFolder) {
   .replace("/page.val.ts", "").replace("/page.val.js", "");
 }
 
-export { VAL_CONFIG_SESSION_STORAGE_KEY as V, _createForOfIteratorHelper as _, VAL_THEME_SESSION_STORAGE_KEY as a, VAL_AI_SESSION_STORAGE_KEY as b, VAL_CANVAS_PARAM as c, VAL_CANVAS_MESSAGE as d, isValCanvasStudioMessage as e, isValCanvasFrame as f, getNextAppRouterSourceFolder as g, getNextAppRouterSitemapTree as h, isValCanvasPageMessage as i, getPatternFromModuleFilePath as j, _objectSpread2 as k, _arrayLikeToArray as l, _unsupportedIterableToArray as m, _defineProperty as n, _typeof as o, parseRoutePattern as p, withValCanvasParam as w };
+export { VAL_CONFIG_SESSION_STORAGE_KEY as V, _createForOfIteratorHelper as _, VAL_THEME_SESSION_STORAGE_KEY as a, VAL_AI_SESSION_STORAGE_KEY as b, VAL_CANVAS_PARAM as c, VAL_CANVAS_MESSAGE as d, isValCanvasStudioMessage as e, isValCanvasFrame as f, getNextAppRouterSourceFolder as g, getTanStackRouterSourceFolder as h, isValCanvasPageMessage as i, getPageRouterSourceFolder as j, isTanStackRoutesFolder as k, getPageRouterSitemapTree as l, getPatternFromModuleFilePath as m, _objectSpread2 as n, _arrayLikeToArray as o, parseRoutePattern as p, _unsupportedIterableToArray as q, _defineProperty as r, _typeof as s, withValCanvasParam as w };

package/dist/{getSitemapTree-77b1203a.cjs.prod.js → getSitemapTree-b320d033.cjs.prod.js}

@@ -137,6 +137,45 @@ function getNextAppRouterSourceFolder(moduleFilePath) {
   return null;
 }
 
+/**
+ * The folder a TanStack Router app keeps its route files in.
+ *
+ * The same question as above for the other convention: `routes/` at the project
+ * root, or under `src/`. A Val module for a route lives beside the route file
+ * and is named the same way, so this is the prefix to strip before reading the
+ * route pattern out of the rest.
+ */
+function getTanStackRouterSourceFolder(moduleFilePath) {
+  if (moduleFilePath.startsWith("/routes/")) {
+    return "/routes";
+  } else if (moduleFilePath.startsWith("/src/routes/")) {
+    return "/src/routes";
+  }
+  return null;
+}
+
+/**
+ * The route folder of whichever page router this module belongs to.
+ *
+ * The two conventions have disjoint prefixes — `app/` versus `routes/` — so a
+ * module file path answers this on its own, which is what the Studio needs: it
+ * walks every schema in the project and has no framework to ask.
+ */
+function getPageRouterSourceFolder(moduleFilePath) {
+  var _getNextAppRouterSour;
+  return (_getNextAppRouterSour = getNextAppRouterSourceFolder(moduleFilePath)) !== null && _getNextAppRouterSour !== void 0 ? _getNextAppRouterSour : getTanStackRouterSourceFolder(moduleFilePath);
+}
+
+/**
+ * Whether a route folder is a TanStack Router one.
+ *
+ * Exported so the pattern derivation and the source-folder detection cannot
+ * drift apart about what `/src/routes` means.
+ */
+function isTanStackRoutesFolder(srcFolder) {
+  return srcFolder === "/routes" || srcFolder === "/src/routes";
+}
+
 function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
@@ -247,8 +286,14 @@ function _createForOfIteratorHelper(r, e) {
   };
 }
 
-// Strictly speaking this should be in the next package but it's shared, because we want to use it in the ui package. We want to resolve that somehow
-function getNextAppRouterSitemapTree(srcFolder, paths) {
+// Strictly speaking this should be in the framework packages but it's shared,
+// because we want to use it in the ui package. We want to resolve that somehow.
+//
+// It is one function for both page routers because the tree it builds is made
+// of URL paths, which is the same thing in either: only `srcFolder` and the
+// pattern derivation differ, and both of those are arguments (or the one call
+// below).
+function getPageRouterSitemapTree(srcFolder, paths) {
   var root = {
     type: "node",
     name: "/",
@@ -360,7 +405,24 @@ function getNextAppRouterSitemapTree(srcFolder, paths) {
   }
   return root;
 }
+
+/**
+ * The route pattern a page-router module serves, e.g. `/blogs/[blog]`.
+ *
+ * Written in Next's vocabulary for both routers on purpose: the pattern is read
+ * by `parseRoutePattern`, the sitemap and the Studio's key inputs, none of which
+ * should have to know which framework the project uses. The TanStack branch
+ * translates that framework's conventions into it; see
+ * `tanStackSegmentsOfRoutePath` in `@valbuild/core` for the rules.
+ */
 function getPatternFromModuleFilePath(moduleFilePath, srcFolder) {
+  if (isTanStackRoutesFolder(srcFolder)) {
+    var routePath = moduleFilePath.slice(srcFolder.length).replace(/\.val\.[tj]sx?$/, "");
+    var segments = core.tanStackSegmentsOfRoutePath(routePath);
+    // "" rather than "/" for the root, so it matches what the Next branch
+    // returns for `/app/page.val.ts` — `parseRoutePattern` reads both as [].
+    return segments.length === 0 ? "" : "/".concat(segments.join("/"));
+  }
   return moduleFilePath.replace(srcFolder, "")
   // TODO: hacky!
   // remove route groups
@@ -379,9 +441,12 @@ exports._defineProperty = _defineProperty;
 exports._objectSpread2 = _objectSpread2;
 exports._typeof = _typeof;
 exports._unsupportedIterableToArray = _unsupportedIterableToArray;
-exports.getNextAppRouterSitemapTree = getNextAppRouterSitemapTree;
 exports.getNextAppRouterSourceFolder = getNextAppRouterSourceFolder;
+exports.getPageRouterSitemapTree = getPageRouterSitemapTree;
+exports.getPageRouterSourceFolder = getPageRouterSourceFolder;
 exports.getPatternFromModuleFilePath = getPatternFromModuleFilePath;
+exports.getTanStackRouterSourceFolder = getTanStackRouterSourceFolder;
+exports.isTanStackRoutesFolder = isTanStackRoutesFolder;
 exports.isValCanvasFrame = isValCanvasFrame;
 exports.isValCanvasPageMessage = isValCanvasPageMessage;
 exports.isValCanvasStudioMessage = isValCanvasStudioMessage;