@bgub/fig-tanstack-start 0.0.0-tegami-trusted-publish-setup → 0.1.0-alpha.2

package/CHANGELOG.md

@@ -0,0 +1,225 @@
+## @bgub/fig-tanstack-start@0.1.0-alpha.1
+
+### Refresh resolves the app's renderer runtime
+
+`figRefresh` now imports `@bgub/fig-dom/refresh` through its bare specifier
+rather than a resolved `/@fs/` path, so app-level aliases, dedupe, and
+prebundling apply and the refresh scheduler cannot be instantiated twice.
+
+### TanStack Start's client graph is prebundled
+
+The TanStack Start adapter now prebundles `@tanstack/start-client-core` in
+development while leaving its application-bound router and Start imports as
+external Vite modules. This reduces the module-request waterfall without
+freezing generated app entries or the linked Fig adapter packages. Production
+continues to use Vite's normal application bundling.
+
+### Make Payload trees directly renderable
+
+`createPayloadComponent` now creates a props-typed component backed by Fig's
+ordinary data store. Complete props form its cache identity by default through
+a canonical encoding of Payload-compatible values, and the component works
+with route loaders and the existing data-resource freshness APIs and explicit
+store handles.
+
+The lower-level `payloadDataLoader` and `PayloadDataLoaderOptions` exports have
+been removed. Use `createPayloadComponent`, or `decodePayloadStream` when
+managing the transport and data integration directly.
+
+TanStack Start replaces `payloadResource({ key, render })` with
+`createPayloadComponent({ key, load: serverPayload(render) })`. Its compiler
+can extract a component imported from `.server.tsx`, while initial companion
+streams, client references, and compiled asset dependencies keep their existing
+transport behavior.
+
+Payload component loaders receive the resolved resource `key` alongside
+`signal`, so framework transports can register responses under the exact cache
+entry without changing ordinary data loaders.
+
+Default keys are canonical across plain-object property order, and Payload
+components use their namespace as their DevTools label. TanStack Start renders
+the supplied component inside the Payload renderer so root-level reads and
+suspension work, and rejects uncompiled `serverPayload` calls before invoking
+application code.
+
+Payload rendering also rejects nesting one Payload component inside another in
+development. Payload components are client-visible delivery boundaries;
+compose ordinary server components inside them or mount separate Payload
+components from the client tree to preserve independent refresh keys.
+
+### Promise-valued children render through Suspense
+
+`FigNode` now accepts promises of nodes. Promise children occupy distinct,
+host-transparent child slots, suspend through the nearest `Suspense`, and route
+rejections or invalid resolved children through normal error handling.
+
+HTML rendering retains exact promise children as independent streaming tasks,
+while Payload uses node-validated promise rows that decode to the same child
+shape. Payload-rendered async components are invoked once and retain their
+component-scoped assets on the outlined row.
+
+### Move HTML escaping helpers to a focused subpath
+
+`escapeAttribute`, `escapeText`, `escapeScriptText`, and `escapeScriptJson` now export from
+`@bgub/fig-server/html` instead of the main `@bgub/fig-server` entry.
+The dedicated subpath keeps companion-markup helpers separate from server
+render entry points while preserving their exact escaping behavior. The
+TanStack Start adapter now consumes these helpers, Fig's internal data-store
+brand predicate, and its own storage-context API instead of duplicating them.
+
+### Expose render-discovered assets as response preload headers
+
+Server stream results now provide a bounded, deduplicated HTTP `Link` value for
+preconnects, fonts, stylesheets, explicit preloads, and module preloads
+discovered before the shell becomes ready. Filters let adapters exclude asset
+URLs that are unsafe for a shared cache.
+
+The TanStack Start renderer can opt into merging that shell snapshot with the
+response's existing `Link` header before constructing the streamed response.
+Assets discovered after the shell continue to arrive through HTML streaming.
+
+### Build generated TanStack Start file routes with Fig
+
+`@bgub/fig-tanstack-router` now implements generated file routes, lazy route
+records, lazy components, and lazy loader functions. TanStack Start builds and
+reloads those routes in development through its existing generator and code
+splitter.
+
+`@bgub/fig-tanstack-start` now exposes Start configuration and middleware
+factories. Its demo covers request-isolated middleware context, server and
+client redirects, generated error and not-found routes, split chunks, SSR,
+hydration, and server-function mutations.
+
+### Complete Fig-native data and navigation patterns
+
+TanStack Start routes can now preload Payload data and return immediately,
+letting Fig Suspense stream the result and its asset resources without copying
+values into Router loader data. Initial Payload responses registered after the
+document shell starts are embedded before hydration, preventing a duplicate
+client request.
+
+The Router adapter adds modern object-only `useBlocker` and reactive
+`useCanGoBack` hooks, makes the concrete Router and RouteApi constructors
+internal, and rejects unsupported proximity preloading in `LinkProps`.
+Fig's structural `ViewTransition` remains the sole document-transition owner,
+even when a TanStack navigation carries its `viewTransition` option.
+
+### Give each matched route ownership of its Fig assets
+
+Route stylesheets, preload hints, preconnects, font preloads, and async scripts
+now enter Fig's shared asset registry at the matched subtree. This gives Start
+streaming, client navigation, and Payload assets one deduplicating ownership
+model while title, meta, inline styles, JSON-LD, and synchronous scripts retain
+their declared document positions.
+
+Manifest `assetCrossOrigin` configuration now belongs to `createRouter`
+options, where it is available before the root match renders.
+
+### Fix first-load styling and development client navigation
+
+Keep TanStack Start's compiler-sensitive client modules out of Vite dependency
+prebundling so client navigation uses the client server-function transport
+instead of executing server-only context access in the browser. Preserve
+browser-extension roots appended to document singletons during hydration so a
+third-party node cannot trigger document replacement and remove stylesheets.
+
+### Compile Payload components and their assets
+
+Fig TanStack Start now turns stylesheet imports in the ordinary component graph
+reached from a `payloadResource` render callback into Payload asset dependencies
+automatically. The same declaration compiles to a private TanStack server
+function and Payload response, so applications no longer author
+`createServerFn`, `renderPayloadResponse`, or request plumbing for Payload
+routes. Payload rendering is independent of filenames. Applications
+conventionally use `.payload.tsx` for the shared resource declaration, but the
+suffix is only a human label. Components and assets referenced only by the
+render callback are omitted from the browser bundle. Compiled styles use the
+existing Payload row ownership, dedupe, streaming, and reveal-gating behavior
+without requiring an `assets(stylesheet(...))` wrapper.
+
+Applications mark the exceptional SSR-plus-hydration boundary with
+`<Isomorphic component={Counter} ... />` and an ordinary static import. The
+generated per-bundle manifest owns module resolution, stable component
+identity, and client CSS metadata, so applications no longer author
+`clientReference`, `createPayloadClientReferenceResolver`, ids, or dynamic
+imports. Ordinary component uses remain Payload-rendered.
+
+### Own the TanStack Start document transport
+
+`StartScripts` now owns Fig data serialization, the initial Payload insertion
+point, and TanStack's bootstrap scripts as one ordered document surface. The
+Payload transport targets a Fig-owned marker instead of matching TanStack's
+private hydration-barrier markup.
+
+The Vite adapter records its exact Router and Start core compatibility profile
+and rejects emitted Solid Router or Start adapter modules. Server-only assets
+are still mirrored into the public client output, but a conflicting client
+asset now fails the build instead of being silently overwritten.
+
+### TanStack Start gains state-preserving Fast Refresh
+
+The TanStack Start Vite adapter now installs Fig Fast Refresh automatically.
+Component edits update in place and preserve hook state in accepted modules.
+
+`@bgub/fig-vite` is now a public package containing the reusable Fast Refresh
+and server data-resource transforms.
+
+### Add Payload routes to the TanStack Start adapter
+
+`@bgub/fig-tanstack-start/payload` now exposes `payloadResource`, which compiles
+an inline render callback into a private server function and Fig-owned route
+data resource. Applications supply the cache key and component tree without
+authoring transport plumbing. The shared declaration can stay in one
+`.payload.tsx` module; its render callback and render-only imports are omitted
+from the browser build. The initial SSR response is embedded into the document
+and adopted without refetching; client navigation and refresh use the same
+resource request path. Payload data rows
+hydrate the shared store, asset resources are retained on their owning server
+segments or inserted through the browser registry, and client references retain
+their resolver-defined identity. `decodePayloadStream` and `payloadDataLoader`
+now expose `retainAssets` for server document renderers that need this delivery
+path.
+
+`@bgub/fig-tanstack-start/server` exposes the lower-level
+`renderPayloadResponse` used by the generated TanStack server function; it
+defaults its render abort signal to the incoming request, so a disconnected
+client cancels the Payload render. Shell
+HTML streams while outlined Suspense holes settle, and the completed initial
+responses are embedded before TanStack starts full-document hydration. The Vite
+adapter also publishes assets imported only by server modules into the client
+build output. Fig Router links also consume TanStack's `viewTransition`
+navigation option without forwarding it as an invalid attribute to the rendered
+anchor, and derive active state from the resolved route instead of an in-flight
+location.
+
+### Add the TanStack Start runtime adapter
+
+`createDataStore` now creates a root-neutral Fig store that route loaders can
+populate before a renderer exists. Server and client renderers adopt that exact
+store, preserving one cache while attaching their lifecycle and scheduling.
+
+The new TanStack Start runtime uses the store for route loading, server
+rendering, Fig-owned document serialization, client deserialization, and
+hydration. Route-managed head and script output maps through the Router adapter,
+including Fig asset resources. The end-to-end contract verifies no initial
+client refetch and exactly one reload after invalidation.
+
+### Build Fig applications with TanStack Start and Vite
+
+`@bgub/fig-tanstack-start/plugin/vite` now delegates client and SSR builds,
+development and preview serving, manifests, and server-function compilation to
+TanStack Start's plugin core. Default entries stream and hydrate Fig documents
+without application-owned build or HTTP glue.
+
+The package root now exposes `createServerFn`. Compiled mutations use TanStack's
+RPC transport and can invalidate the live Fig data store afterward; the demo
+proves the full production flow from SSR hydration through mutation and one
+data-resource refresh.
+
+## @bgub/fig-tanstack-start@0.1.0-alpha.0 (alpha)
+
+### Initial alpha release
+
+First public alpha release of the TanStack Start adapter for Fig.
+
+# Changelog

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Ben Gubler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,282 @@
-# Placeholder package
+# @bgub/fig-tanstack-start
 
-This empty package was published by [Tegami](https://tegami.fuma-nama.dev) to configure npm trusted publishing.
+The TanStack Start adapter for Fig. TanStack owns builds, requests, route
+loading, redirects, and server-function transport; Fig owns rendering, data
+resources, asset resources, and the single data store used by loaders and
+components.
 
-The real package contents will be published via CI with OIDC.
+```bash
+pnpm add @bgub/fig-tanstack-start @bgub/fig-tanstack-router
+```
+
+Add the adapter to Vite:
+
+```ts
+import { tanstackStart } from "@bgub/fig-tanstack-start/plugin/vite";
+
+const plugins = [tanstackStart()];
+```
+
+The plugin supplies the default client and server entries, including streamed
+Fig SSR, full-document hydration, and state-preserving Fig Fast Refresh. It
+currently uses TanStack's Solid target
+as a private compiler compatibility layer because plugin core has no custom
+framework target. The generator currently normalizes file-route constructor
+imports to its Solid package ID; the plugin maps that ID directly to Fig, and no
+Solid Router or Start adapter runtime is installed or bundled. TypeScript needs the corresponding
+compiler-only `paths` entry:
+
+```json
+{
+  "compilerOptions": {
+    "paths": {
+      "@tanstack/solid-router": ["./node_modules/@bgub/fig-tanstack-router"],
+      "@tanstack/solid-start": ["./node_modules/@bgub/fig-tanstack-start"]
+    }
+  }
+}
+```
+
+## Response preload headers
+
+The default server entry leaves response `Link` headers disabled because a CDN
+may cache and replay request-specific asset URLs. A custom server entry can opt
+in globally or provide a resource filter:
+
+```ts
+import { createFigStartHandler } from "@bgub/fig-tanstack-start/server";
+
+const fetch = createFigStartHandler({
+  preloadHeader: {
+    filter: (resource) => resource.href.startsWith("/assets/"),
+  },
+});
+
+export default { fetch };
+```
+
+The header contains assets discovered before Fig's document shell becomes
+ready. Assets discovered later through Suspense or Payload remain in the HTML
+stream and cannot be added after the response is created.
+
+The Start mapping lets the generated registration footer carry middleware
+context types from a conventional `src/start.ts` into `createServerFn`.
+
+Create the router with a root-neutral Fig store:
+
+```tsx
+import { createStartDataContext } from "@bgub/fig-tanstack-start";
+import {
+  createRouter,
+  createRootRouteWithContext,
+} from "@bgub/fig-tanstack-router";
+
+const startData = createStartDataContext();
+const rootRoute = createRootRouteWithContext<typeof startData.context>()({
+  component: Document,
+});
+
+export const router = createRouter({
+  ...startData,
+  routeTree: rootRoute,
+});
+```
+
+The root document renders route-managed assets followed by Start's combined Fig data and TanStack script transport:
+
+```tsx
+import { StartScripts } from "@bgub/fig-tanstack-start";
+import { HeadContent, Outlet } from "@bgub/fig-tanstack-router";
+
+function Document() {
+  return (
+    <html lang="en">
+      <head>
+        <HeadContent />
+      </head>
+      <body>
+        <Outlet />
+        <StartScripts />
+      </body>
+    </html>
+  );
+}
+```
+
+`StartScripts` serializes the Fig store into the server document with Fig's value codec, establishes the adapter's Payload insertion point, and then renders TanStack's bootstrap scripts. Client router creation decodes the data before TanStack hydration can start route loaders; `hydrateStart` repeats that step idempotently as a fallback before `hydrateRoot` adopts the same client store. The first `readData` therefore hits the hydrated entry without re-running its loader, and `invalidateData` operates directly on the live root store.
+
+## Request and function middleware
+
+The package root also exports TanStack's `createStart`, `createMiddleware`, and
+`createCsrfMiddleware`. A conventional `src/start.ts` configures global request
+and server-function middleware:
+
+```ts
+import {
+  createCsrfMiddleware,
+  createMiddleware,
+  createStart,
+} from "@bgub/fig-tanstack-start";
+
+const requestContext = createMiddleware({ type: "request" }).server(
+  ({ request, next }) =>
+    next({ context: { requestId: request.headers.get("x-request-id") } }),
+);
+
+export const startInstance = createStart(() => ({
+  requestMiddleware: [
+    requestContext,
+    createCsrfMiddleware({
+      filter: (context) => context.handlerType === "serverFn",
+    }),
+  ],
+}));
+```
+
+Start's global async context remains request-local across interleaved SSR and
+server-function work. Redirects thrown by generated route loaders or
+`beforeLoad` use Router Core's normal server and client redirect handling.
+
+## Server functions
+
+The package root exports TanStack's `createServerFn`. The Vite plugin compiles
+the handler into the server build and the browser call into an RPC request:
+
+```ts
+import { createServerFn } from "@bgub/fig-tanstack-start";
+
+export const renameUser = createServerFn({ method: "POST" })
+  .validator((input: { id: string; name: string }) => input)
+  .handler(async ({ data }) => {
+    await database.users.rename(data.id, data.name);
+  });
+```
+
+An async event must capture the Fig store before its first `await` when it
+needs to refresh data afterward:
+
+```ts
+import { readDataStore } from "@bgub/fig";
+
+const data = readDataStore();
+await renameUser({ data: { id, name }, signal });
+data.invalidateData(userResource, id);
+```
+
+## Payload routes
+
+Payload routes keep Payload-rendered component trees out of the client bundle
+while using the same Fig data store as ordinary route data. The smallest route
+is one colocated declaration:
+
+```tsx
+// profile.payload.tsx
+import { createPayloadComponent } from "@bgub/fig-dom";
+import { serverPayload } from "@bgub/fig-tanstack-start/payload";
+import { Profile } from "./Profile.server.tsx";
+
+export const ProfilePage = createPayloadComponent<{ id: string }>({
+  key: ["profile-payload"],
+  load: serverPayload(Profile),
+});
+```
+
+`serverPayload` accepts a component or render callback; it is the semantic
+boundary that the compiler extracts into a private server function. It may be
+async. The browser bundle keeps the component handle, cache, and RPC stub; it
+omits the server render and imports used only by it. Keep the Payload component
+declaration in a client-importable module such as `.payload.tsx` because the
+route imports that handle. The rendered component itself may live in a
+TanStack-protected `.server.tsx` module.
+
+When the tree grows, the callback can import ordinary components. Those imports
+also stay out of the browser bundle when only the callback uses them. A filename
+does not cause a component to render through Payload—`serverPayload` does.
+Applications do not call `createServerFn` or `renderPayloadResponse` for Payload
+resources.
+
+Mark the exceptional SSR-plus-hydration boundary with `Isomorphic` and an
+ordinary static component import. For example, a separate Payload component can
+contain the boundary:
+
+```tsx
+import type { FigNode } from "@bgub/fig";
+import { Isomorphic } from "@bgub/fig-tanstack-start/payload";
+import { LikeButton } from "./LikeButton.tsx";
+
+export function Profile({ id }: { id: string }): FigNode {
+  return <Isomorphic component={LikeButton} userId={id} />;
+}
+```
+
+The Vite plugin replaces only the `component` prop with an opaque Payload
+reference and generates its server/browser module resolver. The component
+remains an ordinary export and can render through Payload elsewhere without
+the boundary. `component` must be a named or default static import.
+Applications do not use a `.client.tsx` suffix, `clientReference`,
+`createPayloadClientReferenceResolver`, reference ids, or dynamic imports.
+
+The route can start the load early, then render the component normally:
+
+```tsx
+import { ensureRouteData } from "@bgub/fig-tanstack-router";
+import { createFileRoute } from "@tanstack/solid-router";
+import { ProfilePage } from "../profile.payload.tsx";
+
+export const Route = createFileRoute("/profiles/$id")({
+  loader: ({ context, params }) =>
+    ensureRouteData(context, ProfilePage, { id: params.id }),
+  component: ProfileRoute,
+});
+
+function ProfileRoute() {
+  const { id } = Route.useParams();
+  return <ProfilePage id={id} />;
+}
+```
+
+When the route does not need the tree before commit, preload it and return
+`void`; Fig Suspense then owns the pending UI and stream:
+
+```tsx
+import { Suspense } from "@bgub/fig";
+
+export const Route = createFileRoute("/profiles/$id")({
+  loader: ({ context, params }) => {
+    context.data.preloadData(ProfilePage, { id: params.id });
+  },
+  component: () => (
+    <Suspense fallback={<p>Streaming profile…</p>}>
+      <ProfileRoute />
+    </Suspense>
+  ),
+});
+```
+
+On SSR, Fig decodes and renders the root once, retains Payload-discovered asset
+resources on the rows that declared them, and embeds the response bytes for
+hydration. This includes Payload resources registered after the document shell
+starts. The document renderer emits each asset before its dependent HTML
+segment, including streamed Suspense holes. The browser adopts the embedded
+bytes without a second server-function call. Shell HTML streams while Suspense
+holes settle; TanStack starts full-document hydration after each complete
+initial Payload response is embedded in a keyed carrier. Client navigation and
+refresh use the same raw response path.
+
+The Vite adapter follows ordinary component imports from each `serverPayload`
+render and compiles their static stylesheet imports into Payload asset
+dependencies. Import CSS normally; no manual
+`assets(stylesheet(...))` wrapper or `?url` import is needed. A Payload-rendered
+component's stylesheet is copied from the server build into the public client
+output. An `Isomorphic` component's hashed client CSS is attached through the
+generated manifest. Both use the existing Payload asset row and reveal gate
+and are emitted only when their component renders.
+
+The [`demo-tanstack-start`](../../apps/demo-tanstack-start) app exercises the
+adapter through Vite's production client and SSR builds: generated and split
+file routes, streamed SSR, Router dehydration, Fig-owned data serialization,
+full-document hydration, request-derived themes, view transitions, live
+data-resource invalidation, nested routes, and post and asset Payload trees all
+run through public adapter entries. The asset route embeds two independent
+Payload resources and hydrates an explicit `Isomorphic` component whose CSS and
+SVG are emitted through the production builds.

package/dist/client-B2okTbp3.js

@@ -0,0 +1,29 @@
+import { n as hydrateStartDataStore } from "./transport-DKcSG44e.js";
+import { RouterProvider } from "@bgub/fig-tanstack-router";
+import { hydrateRoot } from "@bgub/fig-dom";
+import { hydrateStart } from "@tanstack/start-client-core/client";
+import { jsx } from "@bgub/fig-dom/jsx-runtime";
+//#region src/client.tsx
+async function hydrateStart$1(options = {}) {
+	const { container = document, ...rootOptions } = options;
+	await waitForRouterBootstrap();
+	const router = await hydrateStart();
+	const dataStore = hydrateStartDataStore(router.options.context, document);
+	const root = hydrateRoot(container, /* @__PURE__ */ jsx(RouterProvider, { router }), {
+		...rootOptions,
+		dataStore
+	});
+	window.$_TSR?.h();
+	return {
+		root,
+		router
+	};
+}
+async function waitForRouterBootstrap() {
+	if (window.$_TSR !== void 0 || document.readyState !== "loading") return;
+	await new Promise((resolve) => document.addEventListener("DOMContentLoaded", () => resolve(), { once: true }));
+}
+//#endregion
+export { hydrateStart$1 as t };
+
+//# sourceMappingURL=client-B2okTbp3.js.map

package/dist/client-B2okTbp3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-B2okTbp3.js","names":["hydrateStart","hydrateTanStackStart"],"sources":["../src/client.tsx"],"sourcesContent":["import {\n  type Container,\n  type FigRoot,\n  type FigRootOptions,\n  hydrateRoot,\n} from \"@bgub/fig-dom\";\nimport { RouterProvider } from \"@bgub/fig-tanstack-router\";\nimport { hydrateStart as hydrateTanStackStart } from \"@tanstack/start-client-core/client\";\nimport type { AnyRouter } from \"@tanstack/router-core\";\nimport { hydrateStartDataStore } from \"./transport.ts\";\n\nexport interface HydrateStartOptions extends Omit<\n  FigRootOptions,\n  \"dataPartition\" | \"dataStore\" | \"initialData\"\n> {\n  container?: Container;\n}\n\nexport interface HydratedStart {\n  root: FigRoot;\n  router: AnyRouter;\n}\n\nexport async function hydrateStart(\n  options: HydrateStartOptions = {},\n): Promise<HydratedStart> {\n  const { container = document, ...rootOptions } = options;\n  await waitForRouterBootstrap();\n  const router = await hydrateTanStackStart();\n  const dataStore = hydrateStartDataStore(router.options.context, document);\n\n  const root = hydrateRoot(container, <RouterProvider router={router} />, {\n    ...rootOptions,\n    dataStore,\n  });\n  window.$_TSR?.h();\n  return { root, router };\n}\n\nasync function waitForRouterBootstrap(): Promise<void> {\n  if (window.$_TSR !== undefined || document.readyState !== \"loading\") return;\n  await new Promise<void>((resolve) =>\n    document.addEventListener(\"DOMContentLoaded\", () => resolve(), {\n      once: true,\n    }),\n  );\n}\n"],"mappings":";;;;;;AAuBA,eAAsBA,eACpB,UAA+B,CAAC,GACR;CACxB,MAAM,EAAE,YAAY,UAAU,GAAG,gBAAgB;CACjD,MAAM,uBAAuB;CAC7B,MAAM,SAAS,MAAMC,aAAqB;CAC1C,MAAM,YAAY,sBAAsB,OAAO,QAAQ,SAAS,QAAQ;CAExE,MAAM,OAAO,YAAY,WAAW,oBAAC,gBAAD,EAAwB,OAAS,CAAA,GAAG;EACtE,GAAG;EACH;CACF,CAAC;CACD,OAAO,OAAO,EAAE;CAChB,OAAO;EAAE;EAAM;CAAO;AACxB;AAEA,eAAe,yBAAwC;CACrD,IAAI,OAAO,UAAU,KAAA,KAAa,SAAS,eAAe,WAAW;CACrE,MAAM,IAAI,SAAe,YACvB,SAAS,iBAAiB,0BAA0B,QAAQ,GAAG,EAC7D,MAAM,KACR,CAAC,CACH;AACF"}

package/dist/client.d.ts

@@ -0,0 +1,13 @@
+import { Container, FigRoot, FigRootOptions } from "@bgub/fig-dom";
+import { AnyRouter } from "@tanstack/router-core";
+//#region src/client.d.ts
+interface HydrateStartOptions extends Omit<FigRootOptions, "dataPartition" | "dataStore" | "initialData"> {
+  container?: Container;
+}
+interface HydratedStart {
+  root: FigRoot;
+  router: AnyRouter;
+}
+declare function hydrateStart(options?: HydrateStartOptions): Promise<HydratedStart>;
+//#endregion
+export { HydrateStartOptions, HydratedStart, hydrateStart };

package/dist/client.js

@@ -0,0 +1,2 @@
+import { t as hydrateStart } from "./client-B2okTbp3.js";
+export { hydrateStart };

package/dist/data.d.ts

@@ -0,0 +1,14 @@
+import { FigDataStoreController, FigNode } from "@bgub/fig";
+import { RouteDataContext } from "@bgub/fig-tanstack-router";
+import { createCsrfMiddleware, createMiddleware, createServerFn, createStart } from "@tanstack/start-client-core";
+import { Register } from "@tanstack/router-core";
+//#region src/data.d.ts
+interface StartDataContext extends RouteDataContext {
+  data: FigDataStoreController;
+}
+declare function createStartDataContext(): {
+  context: StartDataContext;
+};
+declare function StartScripts(): FigNode;
+//#endregion
+export { type Register, StartDataContext, StartScripts, createCsrfMiddleware, createMiddleware, createServerFn, createStart, createStartDataContext };

package/dist/data.js

@@ -0,0 +1,34 @@
+import { a as payloadTransportMarkerId } from "./payload-internal-CZhfVhwH.js";
+import { t as requireStartDataStore } from "./store-CibAGqiI.js";
+import { i as startDataScriptId, r as serializeStartDataStore, t as createStartDataStore } from "./transport-DKcSG44e.js";
+import { createElement } from "@bgub/fig";
+import { HYDRATION_SKIP_ATTRIBUTE } from "@bgub/fig/internal";
+import { Scripts, useRouter } from "@bgub/fig-tanstack-router";
+import { createCsrfMiddleware, createMiddleware, createServerFn, createStart } from "@tanstack/start-client-core";
+//#region src/data.ts
+function createStartDataContext() {
+	return { context: { data: createStartDataStore() } };
+}
+function StartScripts() {
+	const router = useRouter();
+	const routerScripts = createElement(Scripts);
+	if (!router.isServer) return routerScripts;
+	const dataStore = requireStartDataStore(router.options.context);
+	return [
+		createElement("script", {
+			[HYDRATION_SKIP_ATTRIBUTE]: true,
+			id: startDataScriptId,
+			type: "application/json",
+			unsafeHTML: serializeStartDataStore(dataStore)
+		}),
+		createElement("template", {
+			id: payloadTransportMarkerId,
+			[HYDRATION_SKIP_ATTRIBUTE]: true
+		}),
+		routerScripts
+	];
+}
+//#endregion
+export { StartScripts, createCsrfMiddleware, createMiddleware, createServerFn, createStart, createStartDataContext };
+
+//# sourceMappingURL=data.js.map

package/dist/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","names":["RouterScripts"],"sources":["../src/data.ts"],"sourcesContent":["import {\n  createElement,\n  type FigDataStoreController,\n  type FigNode,\n} from \"@bgub/fig\";\nimport { HYDRATION_SKIP_ATTRIBUTE } from \"@bgub/fig/internal\";\nimport {\n  type AnyRouter,\n  type RouteDataContext,\n  Scripts as RouterScripts,\n  useRouter,\n} from \"@bgub/fig-tanstack-router\";\nimport { payloadTransportMarkerId } from \"./document-markers.ts\";\nimport { requireStartDataStore } from \"./store.ts\";\nimport {\n  createStartDataStore,\n  serializeStartDataStore,\n  startDataScriptId,\n} from \"./transport.ts\";\n\nexport {\n  createCsrfMiddleware,\n  createMiddleware,\n  createServerFn,\n  createStart,\n} from \"@tanstack/start-client-core\";\nexport type { Register } from \"@tanstack/router-core\";\n\nexport interface StartDataContext extends RouteDataContext {\n  data: FigDataStoreController;\n}\n\nexport function createStartDataContext(): { context: StartDataContext } {\n  return {\n    context: {\n      data: createStartDataStore(),\n    },\n  };\n}\n\nexport function StartScripts(): FigNode {\n  const router = useRouter<AnyRouter>();\n  const routerScripts = createElement(RouterScripts);\n  if (!router.isServer) return routerScripts;\n\n  const dataStore = requireStartDataStore(router.options.context);\n  return [\n    createElement(\"script\", {\n      [HYDRATION_SKIP_ATTRIBUTE]: true,\n      id: startDataScriptId,\n      type: \"application/json\",\n      unsafeHTML: serializeStartDataStore(dataStore),\n    }),\n    createElement(\"template\", {\n      id: payloadTransportMarkerId,\n      [HYDRATION_SKIP_ATTRIBUTE]: true,\n    }),\n    routerScripts,\n  ];\n}\n"],"mappings":";;;;;;;;AAgCA,SAAgB,yBAAwD;CACtE,OAAO,EACL,SAAS,EACP,MAAM,qBAAqB,EAC7B,EACF;AACF;AAEA,SAAgB,eAAwB;CACtC,MAAM,SAAS,UAAqB;CACpC,MAAM,gBAAgB,cAAcA,OAAa;CACjD,IAAI,CAAC,OAAO,UAAU,OAAO;CAE7B,MAAM,YAAY,sBAAsB,OAAO,QAAQ,OAAO;CAC9D,OAAO;EACL,cAAc,UAAU;IACrB,2BAA2B;GAC5B,IAAI;GACJ,MAAM;GACN,YAAY,wBAAwB,SAAS;EAC/C,CAAC;EACD,cAAc,YAAY;GACxB,IAAI;IACH,2BAA2B;EAC9B,CAAC;EACD;CACF;AACF"}

package/dist/default-entry/client.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/default-entry/client.js

@@ -0,0 +1,7 @@
+import { t as hydrateStart } from "../client-B2okTbp3.js";
+//#region src/default-entry/client.ts
+await hydrateStart();
+//#endregion
+export {};
+
+//# sourceMappingURL=client.js.map

package/dist/default-entry/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":[],"sources":["../../src/default-entry/client.ts"],"sourcesContent":["import { hydrateStart } from \"../client.tsx\";\n\nawait hydrateStart();\n"],"mappings":";;AAEA,MAAM,aAAa"}

package/dist/default-entry/server.d.ts

@@ -0,0 +1,4 @@
+//#region src/default-entry/server.d.ts
+declare const figTanStackStartDefaultServerEntry = true;
+//#endregion
+export { figTanStackStartDefaultServerEntry };