@softr/sdk 0.0.12 → 0.0.13

package/dist/index.d.ts

@@ -1,172 +1,8 @@
-import { _ as SoftrUserGroups, a as DatasourcePermissions, c as ListResult, d as SoftrMe, f as SoftrPermissions, g as SoftrUserGroupId, h as UpdateOptions, i as CreateOptions, l as MetricOptions, m as SoftrUser, n as ChartDataOptions, o as GetOptions, p as SoftrRecord, r as ChartDataResult, s as ListOptions, t as AggregationFunction, u as MetricResult, v as User, y as q } from "./types-n-Sir_Y2.js";
-import * as _tanstack_react_start0 from "@tanstack/react-start";
-
-//#region src/routes/visibility.d.ts
-
-/**
- * Who may see a route.
- *
- * - `ALL_USERS` — everyone, signed in or not.
- * - `NON_LOGGED_IN_USERS` — signed-out visitors only.
- * - `LOGGED_IN_USERS` — signed-in visitors; with `userGroupIds`, only members of
- *   at least one of those groups.
- */
-type RouteVisibility = {
-  userGroup: "ALL_USERS";
-} | {
-  userGroup: "NON_LOGGED_IN_USERS";
-} | {
-  userGroup: "LOGGED_IN_USERS";
-  userGroupIds?: Array<SoftrUserGroupId>;
-};
-/** The route context the root route publishes: the visitor, or `null` when signed out. */
-type SoftrContext = {
-  user: User | null;
-};
-/**
- * Why a visitor was denied.
- *
- * - `unauthenticated` — the route needs a signed-in visitor and there is none.
- * - `forbidden` — signed in, but in none of the groups the route names.
- * - `alreadySignedIn` — the route is for signed-out visitors only.
- */
-declare const ACCESS_REASONS: readonly ["unauthenticated", "forbidden", "alreadySignedIn"];
-type AccessReason = (typeof ACCESS_REASONS)[number];
-/**
- * What a guard does when it refuses a visitor: redirect to a path, or throw an
- * {@link AccessError} for the route's `errorComponent` to render. A bare string
- * is shorthand for redirecting there.
- */
-type AccessBehaviour = string | {
-  strategy: "redirect";
-  to: string;
-} | {
-  strategy: "throw";
-};
-/** Per-reason overrides of the default {@link AccessBehaviour}. */
-type GuardOverrides = Partial<Record<AccessReason, AccessBehaviour>>;
-/** The result of {@link VisibilityHandle.check}: passed, or denied with a reason. */
-type AccessCheck = {
-  ok: true;
-} | {
-  ok: false;
-  reason: AccessReason;
-};
-/**
- * The access error a guard throws. It is plain data, not an `Error` subclass, so
- * take it as `unknown` in an `errorComponent` and narrow it with
- * {@link isAccessError}. It carries the reason and nothing else: the error is
- * serialized into the page, so it never names the groups the route wanted.
- *
- * @example
- * errorComponent: ({ error }: { error: unknown }) =>
- *   isAccessError(error) ? <NoAccess /> : <AppError />
- */
-type AccessError = {
-  type: "access_error";
-  reason: AccessReason;
-};
-/**
- * True for any access error thrown by a guard, whatever its reason.
- *
- * An access error arrives as `unknown` — hydrated from the page, or thrown by
- * anything else at all — so every field is checked before it is narrowed.
- */
-declare function isAccessError(error: unknown): error is AccessError;
-/** True for an access error thrown because nobody was signed in. */
-declare function isUnauthenticatedError(error: unknown): error is AccessError;
-/** True for an access error thrown because the visitor was in none of the groups. */
-declare function isForbiddenError(error: unknown): error is AccessError;
-/** True for an access error thrown because a signed-out-only route saw a user. */
-declare function isAlreadySignedInError(error: unknown): error is AccessError;
-type Narrowed<R extends RouteVisibility> = R extends {
-  userGroup: "LOGGED_IN_USERS";
-} ? SoftrContext & {
-  user: User;
-} : R extends {
-  userGroup: "NON_LOGGED_IN_USERS";
-} ? SoftrContext & {
-  user: null;
-} : SoftrContext;
-/** The four ways to apply a rule, returned by {@link defineVisibility}. */
-type VisibilityHandle<R extends RouteVisibility = RouteVisibility> = {
-  /**
-   * A `beforeLoad` handler that denies a visitor who fails the rule.
-   *
-   * By default an unauthenticated visitor is redirected to `/login`, an already
-   * signed-in one to `/`, and a forbidden one gets an {@link AccessError} thrown
-   * in place, for the route's `errorComponent` to render. Pass `overrides` to
-   * change what any one reason does.
-   *
-   * @example
-   * beforeLoad: visibility.guard({ unauthenticated: "/sign-in" })
-   */
-  guard(overrides?: GuardOverrides): (opts: {
-    context: SoftrContext;
-  }) => void;
-  /**
-   * Throws the same access error or redirect `guard()` would, for code that
-   * needs to run its own checks after the rule.
-   *
-   * @example
-   * beforeLoad: ({ context }) => {
-   *   visibility.assert(context)
-   *   if (context.user.trialExpired) throw redirect({ to: "/renew" })
-   * }
-   */
-  assert(context: SoftrContext): void;
-  /**
-   * Whether the visitor passes the rule. Narrows `context.user` where the rule
-   * allows it.
-   */
-  isAuthorized(context: SoftrContext): context is Narrowed<R>;
-  /** The decision and, when a visitor is refused, the reason. Throws nothing. */
-  check(context: SoftrContext): AccessCheck;
-};
-/**
- * Declares who may see a route, and returns the handle that enforces it.
- *
- * One call per route file, at module scope: the build reads these declarations
- * to publish the app's route visibility, so the rule must be a literal.
- *
- * @example
- * const visibility = defineVisibility({ userGroup: "LOGGED_IN_USERS" })
- *
- * export const Route = createFileRoute("/about")({
- *   beforeLoad: visibility.guard(),
- *   component: About,
- * })
- */
-declare function defineVisibility<const R extends RouteVisibility>(rule: R): VisibilityHandle<R>;
-//#endregion
-//#region src/auth/isomorphic.d.ts
-/**
- * Resolves the Softr visitor for every request, so that `getSoftrUser` and the
- * route guards have someone to check.
- *
- * Register it once, as a global request middleware in the app's `src/start.ts`.
- * It touches nothing but the visitor.
- *
- * @example
- * export const startInstance = createStart(() => ({
- *   requestMiddleware: [softrAuthMiddleware()],
- * }))
- */
-declare function softrAuthMiddleware(): _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, {
-  user: User | null;
-}>;
-/**
- * Returns the signed-in visitor, or `null` when nobody is signed in.
- *
- * Await it in the root route's `beforeLoad` to publish the visitor as route
- * context, which every `defineVisibility` guard then reads. It requires
- * {@link softrAuthMiddleware} to be registered.
- *
- * @example
- * export const Route = createRootRouteWithContext<SoftrContext>()({
- *   beforeLoad: async () => ({ user: await getSoftrUser() }),
- * })
- */
-declare const getSoftrUser: _tanstack_react_start0.OptionalFetcher<undefined, undefined, Promise<User | null>>;
-//#endregion
-export { type AccessBehaviour, type AccessCheck, type AccessError, type AccessReason, type AggregationFunction, type ChartDataOptions, type ChartDataResult, type CreateOptions, type DatasourcePermissions, type GetOptions, type ListOptions, type ListResult, type MetricOptions, type MetricResult, type RouteVisibility, type SoftrContext, type SoftrMe, type SoftrPermissions, type SoftrRecord, type SoftrUser, type SoftrUserGroupId, type SoftrUserGroups, type UpdateOptions, type User, type VisibilityHandle, defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware };
+import { q } from "./core/query.js";
+import { SoftrUserGroupId, SoftrUserGroups, User } from "./auth/user.js";
+import { AggregationFunction, ChartDataOptions, ChartDataResult, CreateOptions, DatasourcePermissions, GetOptions, ListOptions, ListResult, MetricOptions, MetricResult, SoftrMe, SoftrPermissions, SoftrRecord, SoftrUser, UpdateOptions } from "./types.js";
+import { Permissions } from "./auth/permissions.js";
+import { SoftrContext } from "./auth/context.js";
+import { AccessBehaviour, AccessCheck, AccessError, AccessReason, RouteVisibility, VisibilityHandle, defineVisibility, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError } from "./routes/visibility.js";
+import { getSoftrContext, initialSoftrContext, softrAuthMiddleware, useCurrentUser, usePermissions } from "./auth/isomorphic.js";
+export { type AccessBehaviour, type AccessCheck, type AccessError, type AccessReason, type AggregationFunction, type ChartDataOptions, type ChartDataResult, type CreateOptions, type DatasourcePermissions, type GetOptions, type ListOptions, type ListResult, type MetricOptions, type MetricResult, type Permissions, type RouteVisibility, type SoftrContext, type SoftrMe, type SoftrPermissions, type SoftrRecord, type SoftrUser, type SoftrUserGroupId, type SoftrUserGroups, type UpdateOptions, type User, type VisibilityHandle, defineVisibility, getSoftrContext, initialSoftrContext, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware, useCurrentUser, usePermissions };

package/dist/index.js

@@ -1,177 +1,5 @@
-import { a as readSessionToken, i as readSessionData, l as writeCookies, n as makeSessionDataCookie, o as fetchVisitor, t as clearSession, u as assert, v as q } from "./session-kTqxT5_K.js";
-import { redirect } from "@tanstack/react-router";
-import { createMiddleware, createServerFn, getGlobalStartContext } from "@tanstack/react-start";
+import { q } from "./core/query.js";
+import { defineVisibility, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError } from "./routes/visibility.js";
+import { getSoftrContext, initialSoftrContext, softrAuthMiddleware, useCurrentUser, usePermissions } from "./auth/isomorphic.js";
 
-//#region src/routes/visibility.ts
-/**
-* Why a visitor was denied.
-*
-* - `unauthenticated` — the route needs a signed-in visitor and there is none.
-* - `forbidden` — signed in, but in none of the groups the route names.
-* - `alreadySignedIn` — the route is for signed-out visitors only.
-*/
-const ACCESS_REASONS = [
-	"unauthenticated",
-	"forbidden",
-	"alreadySignedIn"
-];
-/** Decides whether a visitor passes a visibility rule, without throwing. */
-function checkAccess(rule, context) {
-	const { user } = context;
-	switch (rule.userGroup) {
-		case "ALL_USERS": return { ok: true };
-		case "NON_LOGGED_IN_USERS": return user === null ? { ok: true } : {
-			ok: false,
-			reason: "alreadySignedIn"
-		};
-		case "LOGGED_IN_USERS": {
-			if (user === null) return {
-				ok: false,
-				reason: "unauthenticated"
-			};
-			const required = rule.userGroupIds ?? [];
-			if (required.length === 0) return { ok: true };
-			return required.some((id) => user.userGroupIds.includes(id)) ? { ok: true } : {
-				ok: false,
-				reason: "forbidden"
-			};
-		}
-	}
-}
-function isAccessReason(value) {
-	return ACCESS_REASONS.some((reason) => reason === value);
-}
-/**
-* True for any access error thrown by a guard, whatever its reason.
-*
-* An access error arrives as `unknown` — hydrated from the page, or thrown by
-* anything else at all — so every field is checked before it is narrowed.
-*/
-function isAccessError(error) {
-	if (typeof error !== "object" || error === null) return false;
-	const candidate = error;
-	if (candidate.type !== "access_error") return false;
-	return isAccessReason(candidate.reason);
-}
-function isReason(error, reason) {
-	return isAccessError(error) && error.reason === reason;
-}
-/** True for an access error thrown because nobody was signed in. */
-function isUnauthenticatedError(error) {
-	return isReason(error, "unauthenticated");
-}
-/** True for an access error thrown because the visitor was in none of the groups. */
-function isForbiddenError(error) {
-	return isReason(error, "forbidden");
-}
-/** True for an access error thrown because a signed-out-only route saw a user. */
-function isAlreadySignedInError(error) {
-	return isReason(error, "alreadySignedIn");
-}
-const DEFAULT_ACCESS_BEHAVIOUR = {
-	unauthenticated: {
-		strategy: "redirect",
-		to: "/login"
-	},
-	forbidden: { strategy: "throw" },
-	alreadySignedIn: {
-		strategy: "redirect",
-		to: "/"
-	}
-};
-/** What a guard throws for a reason: a redirect, or an {@link AccessError}. */
-function thrownFor(reason, overrides) {
-	const behaviour = overrides?.[reason] ?? DEFAULT_ACCESS_BEHAVIOUR[reason];
-	const resolved = typeof behaviour === "string" ? {
-		strategy: "redirect",
-		to: behaviour
-	} : behaviour;
-	if (resolved.strategy === "redirect") return redirect({ to: resolved.to });
-	return {
-		type: "access_error",
-		reason
-	};
-}
-/**
-* Declares who may see a route, and returns the handle that enforces it.
-*
-* One call per route file, at module scope: the build reads these declarations
-* to publish the app's route visibility, so the rule must be a literal.
-*
-* @example
-* const visibility = defineVisibility({ userGroup: "LOGGED_IN_USERS" })
-*
-* export const Route = createFileRoute("/about")({
-*   beforeLoad: visibility.guard(),
-*   component: About,
-* })
-*/
-function defineVisibility(rule) {
-	return {
-		guard: (overrides) => ({ context }) => {
-			const result = checkAccess(rule, context);
-			if (result.ok) return;
-			throw thrownFor(result.reason, overrides);
-		},
-		assert: (context) => {
-			const result = checkAccess(rule, context);
-			if (result.ok) return;
-			throw thrownFor(result.reason, void 0);
-		},
-		isAuthorized: (context) => checkAccess(rule, context).ok,
-		check: (context) => checkAccess(rule, context)
-	};
-}
-
-//#endregion
-//#region src/auth/isomorphic.ts
-/**
-* Resolves the Softr visitor for every request, so that `getSoftrUser` and the
-* route guards have someone to check.
-*
-* Register it once, as a global request middleware in the app's `src/start.ts`.
-* It touches nothing but the visitor.
-*
-* @example
-* export const startInstance = createStart(() => ({
-*   requestMiddleware: [softrAuthMiddleware()],
-* }))
-*/
-function softrAuthMiddleware() {
-	return createMiddleware({ type: "request" }).server(async ({ next }) => {
-		async function getUser() {
-			const token = readSessionToken();
-			if (token === null) return null;
-			const cached = readSessionData(token);
-			if (cached !== null) return cached;
-			const user = await fetchVisitor(token);
-			if (user === null) {
-				clearSession();
-				return null;
-			}
-			writeCookies([makeSessionDataCookie(user, token)]);
-			return user;
-		}
-		return next({ context: { user: await getUser() } });
-	});
-}
-/**
-* Returns the signed-in visitor, or `null` when nobody is signed in.
-*
-* Await it in the root route's `beforeLoad` to publish the visitor as route
-* context, which every `defineVisibility` guard then reads. It requires
-* {@link softrAuthMiddleware} to be registered.
-*
-* @example
-* export const Route = createRootRouteWithContext<SoftrContext>()({
-*   beforeLoad: async () => ({ user: await getSoftrUser() }),
-* })
-*/
-const getSoftrUser = createServerFn({ method: "GET" }).handler(async () => {
-	const context = getGlobalStartContext();
-	assert(typeof context === "object" && context !== null && "user" in context, "softrAuthMiddleware has not run: the Start global context carries no `user`. Register it as a global request middleware, e.g. createStart(() => ({ requestMiddleware: [softrAuthMiddleware()] })).");
-	return context.user ?? null;
-});
-
-//#endregion
-export { defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware };
+export { defineVisibility, getSoftrContext, initialSoftrContext, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware, useCurrentUser, usePermissions };

package/dist/routes/discover.d.ts

@@ -0,0 +1,9 @@
+import "@tanstack/router-generator";
+
+//#region src/routes/discover.d.ts
+
+type VisibilityValue = string | Array<VisibilityValue> | {
+  [key: string]: VisibilityValue;
+};
+//#endregion
+export { VisibilityValue };

package/dist/routes/discover.js

@@ -0,0 +1,198 @@
+import { createReadOnlyFs } from "./mem-fs.js";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { Generator, getConfig } from "@tanstack/router-generator";
+import os from "node:os";
+import { parse } from "@babel/parser";
+import babelTraverse from "@babel/traverse";
+
+//#region src/routes/discover.ts
+async function crawlRoutes(opts) {
+	const config = getConfig({
+		disableLogging: true,
+		tmpDir: TMP_DIR,
+		generatedRouteTree: generatedRouteTreePath()
+	}, opts.root);
+	const generator = new Generator({
+		config,
+		root: opts.root,
+		fs: createReadOnlyFs()
+	});
+	await generator.run();
+	const crawlingResult = await generator.getCrawlingResult();
+	if (!crawlingResult) throw new Error(`the route crawl produced no result for ${opts.root}`);
+	return {
+		rootRouteNode: crawlingResult.rootRouteNode,
+		routeNodes: crawlingResult.acc.routeNodes,
+		routePiecesByPath: crawlingResult.acc.routePiecesByPath,
+		routeTree: crawlingResult.acc.routeTree,
+		routesDirectory: path.relative(opts.root, path.resolve(opts.root, config.routesDirectory)).split(path.sep).join("/")
+	};
+}
+/** Reads the rule out of the source text. The route file is never executed. */
+function extractVisibility(source, filePath) {
+	let program;
+	try {
+		program = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+	} catch (error) {
+		const position = error.loc;
+		return fail("unparsable", `could not parse ${filePath}: ${error.message}`, filePath, position?.line ?? 1, position?.column ?? 0);
+	}
+	const calls = findVisibilityCalls(program);
+	if (calls.length > 1) {
+		const second = calls[1].call;
+		return fail("duplicate-declaration", `${filePath} declares visibility more than once; a route has exactly one rule`, filePath, second.loc?.start.line ?? 1, second.loc?.start.column ?? 0);
+	}
+	const declaration = calls[0];
+	if (declaration === void 0) return {
+		ok: true,
+		visibility: null
+	};
+	const { call, statement } = declaration;
+	const argument = call.arguments[0];
+	if (argument === void 0) return fail("not-literal", `${filePath} calls ${VISIBILITY_FUNCTION} with no argument`, filePath, call.loc?.start.line ?? 1, call.loc?.start.column ?? 0);
+	const read = readLiteral(argument);
+	if (!read.ok) return fail("not-literal", `${filePath}: the visibility rule must be a literal — ${read.reason}`, filePath, read.line, read.column);
+	return {
+		ok: true,
+		visibility: {
+			value: read.value,
+			line: statement.loc?.start.line ?? 1,
+			column: statement.loc?.start.column ?? 0
+		}
+	};
+}
+/**
+* The generator `mkdirSync`s `tmpDir` and the directory of `generatedRouteTree` outside the `fs`
+* shim, so defaulted they create directories in the crawled project. Aimed at `os.tmpdir()` both
+* calls are no-ops, and nothing is ever written through either path. The uuid keeps the generated
+* tree file a miss rather than whatever a shared temp directory happens to hold.
+*/
+const TMP_DIR = os.tmpdir();
+const generatedRouteTreePath = () => path.join(TMP_DIR, `softr-sdk-route-tree-${randomUUID()}.gen.ts`);
+const SDK_PACKAGE_NAME = "@softr/sdk";
+const VISIBILITY_FUNCTION = "defineVisibility";
+function fail(code, message, filePath, line, column) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message,
+			filePath,
+			line,
+			column
+		}
+	};
+}
+const traverse = babelTraverse.default ?? babelTraverse;
+/** Only a call initialising a top-level variable counts; one inside a function or block does not. */
+function findVisibilityCalls(ast) {
+	const found = [];
+	traverse(ast, { VariableDeclarator(path$1) {
+		const list = path$1.parentPath;
+		if (!list.isVariableDeclaration()) return;
+		const statement = list.parentPath.isExportNamedDeclaration() ? list.parentPath : list;
+		if (!statement.parentPath?.isProgram()) return;
+		if (path$1.node.init === null || path$1.node.init === void 0) return;
+		const call = unwrap(path$1.node.init);
+		if (call.type !== "CallExpression" && call.type !== "OptionalCallExpression") return;
+		if (call.callee.type !== "Identifier") return;
+		if (!isVisibilityImport(path$1, call.callee.name)) return;
+		found.push({
+			call,
+			statement: statement.node
+		});
+	} });
+	return found;
+}
+function isVisibilityImport(path$1, name) {
+	const binding = path$1.scope.getBinding(name);
+	if (binding === void 0 || binding.kind !== "module") return false;
+	const specifier = binding.path.node;
+	const declaration = binding.path.parent;
+	if (specifier.type !== "ImportSpecifier" || declaration.type !== "ImportDeclaration") return false;
+	if (specifier.importKind === "type" || declaration.importKind === "type") return false;
+	if (declaration.source.value !== SDK_PACKAGE_NAME) return false;
+	return (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) === VISIBILITY_FUNCTION;
+}
+/** Strips the wrappers that leave the runtime value unchanged: `as const`, `satisfies`, `!`, `()`. */
+function unwrap(node) {
+	switch (node.type) {
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+		case "TSTypeAssertion":
+		case "TSInstantiationExpression":
+		case "ParenthesizedExpression": return unwrap(node.expression);
+		default: return node;
+	}
+}
+function reject(node, reason) {
+	return {
+		ok: false,
+		reason,
+		line: node.loc?.start.line ?? 1,
+		column: node.loc?.start.column ?? 0
+	};
+}
+function readLiteral(input) {
+	const node = unwrap(input);
+	switch (node.type) {
+		case "StringLiteral": return {
+			ok: true,
+			value: node.value
+		};
+		case "TemplateLiteral":
+			if (node.expressions.length > 0) return reject(node, "a template literal with an expression is not a static value");
+			return {
+				ok: true,
+				value: node.quasis[0]?.value.cooked ?? ""
+			};
+		case "ArrayExpression": {
+			const values = [];
+			for (const element of node.elements) {
+				if (element === null) return reject(node, "an array hole is not a static value");
+				if (element.type === "SpreadElement") return reject(element, "a spread is not a static value");
+				const read = readLiteral(element);
+				if (!read.ok) return read;
+				values.push(read.value);
+			}
+			return {
+				ok: true,
+				value: values
+			};
+		}
+		case "ObjectExpression": {
+			const value = {};
+			for (const property of node.properties) {
+				if (property.type === "SpreadElement") return reject(property, "a spread is not a static value");
+				if (property.type === "ObjectMethod") return reject(property, "a method is not a static value");
+				if (property.computed) return reject(property, "a computed key is not a static value");
+				if (property.shorthand) return reject(property, "a shorthand property is not a static value");
+				const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "StringLiteral" ? property.key.value : null;
+				if (key === null) return reject(property.key, "this key is not a static value");
+				if (key === "__proto__") return reject(property.key, "a __proto__ key is not a static value");
+				const read = readLiteral(property.value);
+				if (!read.ok) return read;
+				value[key] = read.value;
+			}
+			return {
+				ok: true,
+				value
+			};
+		}
+		case "NumericLiteral":
+		case "BooleanLiteral":
+		case "NullLiteral": return reject(node, "a visibility rule is built from strings, arrays and objects");
+		case "Identifier": return reject(node, `an identifier (${node.name}) is not a static value`);
+		case "CallExpression":
+		case "NewExpression": return reject(node, "a call is not a static value");
+		default: return reject(node, `${node.type} is not a static value`);
+	}
+}
+
+//#endregion
+export { crawlRoutes, extractVisibility };

package/dist/routes/manifest.d.ts

@@ -0,0 +1,17 @@
+import { VisibilityValue } from "./discover.js";
+
+//#region src/routes/manifest.d.ts
+type ManifestNode = {
+  routePath: string;
+  filePath: string;
+  _fsRouteType?: string;
+  inferFullPath: string | null;
+  createFileRouteProps: Array<string>;
+  visibility: VisibilityValue | null;
+  children: Array<ManifestNode>;
+};
+type Manifest = {
+  root: ManifestNode;
+};
+//#endregion
+export { Manifest, ManifestNode };