feat: sync docs (by copying them) (#69)

This implements a different approach to syncing the docs. Rather than creating a toolchain that requires git sync or similar on build and keeps things transient, this approach implements a script that is invoked separately (and can be part of a github action for example) that mostly copies the documentation from the target repositories over into the omnisite, while also invoking scripts for creating the generated reference docs. The result is saved to disk, which has a few advantages:
- build is massively simpler: no dependencies on flaky git or other remote sources, as everything is already there
- getting started is easier, no need to sync first, just checkout the repo and go. This is especially helpful if you're working on the site itself, not the content
- translations will be easier: just don't invoke the sync script, instead modify the directories by hand. Keeping up to date with the source will also be easier because you can git-diff changes to docs

Closes #20

apps/svelte.dev/.gitignore

@@ -6,4 +6,7 @@
 /src/routes/_home/Supporters/contributors.js
 /src/routes/_home/Supporters/donors.jpg
 /src/routes/_home/Supporters/donors.js
-/static/svelte-app.json
+/static/svelte-app.json
+
+# git-repositories of synced docs go here
+/repos/

apps/svelte.dev/.prettierignore

@@ -1,3 +1,3 @@
-_generated.md
+content/docs
 scripts/create-tutorial-zip/common/.svelte-kit
 land-110m.json

apps/svelte.dev/content/docs/kit/10-getting-started/10-introduction.md

@@ -0,0 +1,27 @@
+---
+title: Introduction
+---
+
+## Before we begin
+
+> If you're new to Svelte or SvelteKit we recommend checking out the [interactive tutorial](https://learn.svelte.dev).
+>
+> If you get stuck, reach out for help in the [Discord chatroom](https://svelte.dev/chat).
+
+## What is SvelteKit?
+
+SvelteKit is a framework for rapidly developing robust, performant web applications using [Svelte](https://svelte.dev/). If you're coming from React, SvelteKit is similar to Next. If you're coming from Vue, SvelteKit is similar to Nuxt.
+
+To learn more about the kinds of applications you can build with SvelteKit, see the [FAQ](/docs/faq#what-can-i-make-with-sveltekit).
+
+## What is Svelte?
+
+In short, Svelte is a way of writing user interface components — like a navigation bar, comment section, or contact form — that users see and interact with in their browsers. The Svelte compiler converts your components to JavaScript that can be run to render the HTML for the page and to CSS that styles the page. You don't need to know Svelte to understand the rest of this guide, but it will help. If you'd like to learn more, check out [the Svelte tutorial](https://svelte.dev/tutorial).
+
+## SvelteKit vs Svelte
+
+Svelte renders UI components. You can compose these components and render an entire page with just Svelte, but you need more than just Svelte to write an entire app.
+
+SvelteKit helps you build web apps while following modern best practices and providing solutions to common development challenges. It offers everything from basic functionalities — like a [router](glossary#routing) that updates your UI when a link is clicked — to more advanced capabilities. Its extensive list of features includes [build optimizations](https://vitejs.dev/guide/features.html#build-optimizations) to load only the minimal required code; [offline support](service-workers); [preloading](link-options#data-sveltekit-preload-data) pages before user navigation; [configurable rendering](page-options) to handle different parts of your app on the server via [SSR](glossary#ssr), in the browser through [client-side rendering](glossary#csr), or at build-time with [prerendering](glossary#prerendering); [image optimization](images); and much more. Building an app with all the modern best practices is fiendishly complicated, but SvelteKit does all the boring stuff for you so that you can get on with the creative part.
+
+It reflects changes to your code in the browser instantly to provide a lightning-fast and feature-rich development experience by leveraging [Vite](https://vitejs.dev/) with a [Svelte plugin](https://github.com/sveltejs/vite-plugin-svelte) to do [Hot Module Replacement (HMR)](https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/config.md#hot).

apps/svelte.dev/content/docs/kit/10-getting-started/20-creating-a-project.md

@@ -0,0 +1,25 @@
+---
+title: Creating a project
+---
+
+The easiest way to start building a SvelteKit app is to run `npm create`:
+
+```bash
+npm create svelte@latest my-app
+cd my-app
+npm install
+npm run dev
+```
+
+The first command will scaffold a new project in the `my-app` directory asking you if you'd like to set up some basic tooling such as TypeScript. See [integrations](./integrations) for pointers on setting up additional tooling. The subsequent commands will then install its dependencies and start a server on [localhost:5173](http://localhost:5173).
+
+There are two basic concepts:
+
+- Each page of your app is a [Svelte](https://svelte.dev) component
+- You create pages by adding files to the `src/routes` directory of your project. These will be server-rendered so that a user's first visit to your app is as fast as possible, then a client-side app takes over
+
+Try editing the files to get a feel for how everything works.
+
+## Editor setup
+
+We recommend using [Visual Studio Code (aka VS Code)](https://code.visualstudio.com/download) with [the Svelte extension](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode), but [support also exists for numerous other editors](https://sveltesociety.dev/resources#editor-support).

apps/svelte.dev/content/docs/kit/10-getting-started/30-project-structure.md

@@ -0,0 +1,92 @@
+---
+title: Project structure
+---
+
+A typical SvelteKit project looks like this:
+
+```bash
+my-project/
+├ src/
+│ ├ lib/
+│ │ ├ server/
+│ │ │ └ [your server-only lib files]
+│ │ └ [your lib files]
+│ ├ params/
+│ │ └ [your param matchers]
+│ ├ routes/
+│ │ └ [your routes]
+│ ├ app.html
+│ ├ error.html
+│ ├ hooks.client.js
+│ ├ hooks.server.js
+│ └ service-worker.js
+├ static/
+│ └ [your static assets]
+├ tests/
+│ └ [your tests]
+├ package.json
+├ svelte.config.js
+├ tsconfig.json
+└ vite.config.js
+```
+
+You'll also find common files like `.gitignore` and `.npmrc` (and `.prettierrc` and `eslint.config.js` and so on, if you chose those options when running `npm create svelte@latest`).
+
+## Project files
+
+### src
+
+The `src` directory contains the meat of your project. Everything except `src/routes` and `src/app.html` is optional.
+
+- `lib` contains your library code (utilities and components), which can be imported via the [`$lib`](modules#$lib) alias, or packaged up for distribution using [`svelte-package`](packaging)
+  - `server` contains your server-only library code. It can be imported by using the [`$lib/server`](server-only-modules) alias. SvelteKit will prevent you from importing these in client code.
+- `params` contains any [param matchers](advanced-routing#matching) your app needs
+- `routes` contains the [routes](routing) of your application. You can also colocate other components that are only used within a single route here
+- `app.html` is your page template — an HTML document containing the following placeholders:
+  - `%sveltekit.head%` — `<link>` and `<script>` elements needed by the app, plus any `<svelte:head>` content
+  - `%sveltekit.body%` — the markup for a rendered page. This should live inside a `<div>` or other element, rather than directly inside `<body>`, to prevent bugs caused by browser extensions injecting elements that are then destroyed by the hydration process. SvelteKit will warn you in development if this is not the case
+  - `%sveltekit.assets%` — either [`paths.assets`](configuration#paths), if specified, or a relative path to [`paths.base`](configuration#paths)
+  - `%sveltekit.nonce%` — a [CSP](configuration#csp) nonce for manually included links and scripts, if used
+  - `%sveltekit.env.[NAME]%` - this will be replaced at render time with the `[NAME]` environment variable, which must begin with the [`publicPrefix`](configuration#env) (usually `PUBLIC_`). It will fallback to `''` if not matched.
+- `error.html` is the page that is rendered when everything else fails. It can contain the following placeholders:
+  - `%sveltekit.status%` — the HTTP status
+  - `%sveltekit.error.message%` — the error message
+- `hooks.client.js` contains your client [hooks](hooks)
+- `hooks.server.js` contains your server [hooks](hooks)
+- `service-worker.js` contains your [service worker](service-workers)
+
+(Whether the project contains `.js` or `.ts` files depends on whether you opt to use TypeScript when you create your project. You can switch between JavaScript and TypeScript in the documentation using the toggle at the bottom of this page.)
+
+If you added [Vitest](https://vitest.dev) when you set up your project, your unit tests will live in the `src` directory with a `.test.js` extension.
+
+### static
+
+Any static assets that should be served as-is, like `robots.txt` or `favicon.png`, go in here.
+
+### tests
+
+If you added [Playwright](https://playwright.dev/) for browser testing when you set up your project, the tests will live in this directory.
+
+### package.json
+
+Your `package.json` file must include `@sveltejs/kit`, `svelte` and `vite` as `devDependencies`.
+
+When you create a project with `npm create svelte@latest`, you'll also notice that `package.json` includes `"type": "module"`. This means that `.js` files are interpreted as native JavaScript modules with `import` and `export` keywords. Legacy CommonJS files need a `.cjs` file extension.
+
+### svelte.config.js
+
+This file contains your Svelte and SvelteKit [configuration](configuration).
+
+### tsconfig.json
+
+This file (or `jsconfig.json`, if you prefer type-checked `.js` files over `.ts` files) configures TypeScript, if you added typechecking during `npm create svelte@latest`. Since SvelteKit relies on certain configuration being set a specific way, it generates its own `.svelte-kit/tsconfig.json` file which your own config `extends`.
+
+### vite.config.js
+
+A SvelteKit project is really just a [Vite](https://vitejs.dev) project that uses the [`@sveltejs/kit/vite`](modules#sveltejs-kit-vite) plugin, along with any other [Vite configuration](https://vitejs.dev/config/).
+
+## Other files
+
+### .svelte-kit
+
+As you develop and build your project, SvelteKit will generate files in a `.svelte-kit` directory (configurable as [`outDir`](configuration#outdir)). You can ignore its contents, and delete them at any time (they will be regenerated when you next `dev` or `build`).

apps/svelte.dev/content/docs/kit/10-getting-started/40-web-standards.md

@@ -0,0 +1,106 @@
+---
+title: Web standards
+---
+
+Throughout this documentation, you'll see references to the standard [Web APIs](https://developer.mozilla.org/en-US/docs/Web/API) that SvelteKit builds on top of. Rather than reinventing the wheel, we _use the platform_, which means your existing web development skills are applicable to SvelteKit. Conversely, time spent learning SvelteKit will help you be a better web developer elsewhere.
+
+These APIs are available in all modern browsers and in many non-browser environments like Cloudflare Workers, Deno, and Vercel Functions. During development, and in [adapters](adapters) for Node-based environments (including AWS Lambda), they're made available via polyfills where necessary (for now, that is — Node is rapidly adding support for more web standards).
+
+In particular, you'll get comfortable with the following:
+
+## Fetch APIs
+
+SvelteKit uses [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch) for getting data from the network. It's available in [hooks](hooks) and [server routes](routing#server) as well as in the browser.
+
+> A special version of `fetch` is available in [`load`](load) functions, [server hooks](hooks#server-hooks) and [API routes](routing#server) for invoking endpoints directly during server-side rendering, without making an HTTP call, while preserving credentials. (To make credentialled fetches in server-side code outside `load`, you must explicitly pass `cookie` and/or `authorization` headers.) It also allows you to make relative requests, whereas server-side `fetch` normally requires a fully qualified URL.
+
+Besides `fetch` itself, the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) includes the following interfaces:
+
+### Request
+
+An instance of [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) is accessible in [hooks](hooks) and [server routes](routing#server) as `event.request`. It contains useful methods like `request.json()` and `request.formData()` for getting data that was posted to an endpoint.
+
+### Response
+
+An instance of [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) is returned from `await fetch(...)` and handlers in `+server.js` files. Fundamentally, a SvelteKit app is a machine for turning a `Request` into a `Response`.
+
+### Headers
+
+The [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers) interface allows you to read incoming `request.headers` and set outgoing `response.headers`. For example, you can get the `request.headers` as shown below, and use the [`json` convenience function](modules#sveltejs-kit-json) to send modified `response.headers`:
+
+```js
+// @errors: 2461
+/// file: src/routes/what-is-my-user-agent/+server.js
+import { json } from '@sveltejs/kit';
+
+/** @type {import('./$types').RequestHandler} */
+export function GET({ request }) {
+	// log all headers
+	console.log(...request.headers);
+
+	// create a JSON Response using a header we received
+	return json({
+		// retrieve a specific header
+		userAgent: request.headers.get('user-agent')
+	}, {
+		// set a header on the response
+		headers: { 'x-custom-header': 'potato' }
+	});
+}
+```
+
+## FormData
+
+When dealing with HTML native form submissions you'll be working with [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) objects.
+
+```js
+// @errors: 2461
+/// file: src/routes/hello/+server.js
+import { json } from '@sveltejs/kit';
+
+/** @type {import('./$types').RequestHandler} */
+export async function POST(event) {
+	const body = await event.request.formData();
+
+	// log all fields
+	console.log([...body]);
+
+	return json({
+		// get a specific field's value
+		name: body.get('name') ?? 'world'
+	});
+}
+```
+
+## Stream APIs
+
+Most of the time, your endpoints will return complete data, as in the `userAgent` example above. Sometimes, you may need to return a response that's too large to fit in memory in one go, or is delivered in chunks, and for this the platform provides [streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) — [ReadableStream](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream), [WritableStream](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream) and [TransformStream](https://developer.mozilla.org/en-US/docs/Web/API/TransformStream).
+
+## URL APIs
+
+URLs are represented by the [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) interface, which includes useful properties like `origin` and `pathname` (and, in the browser, `hash`). This interface shows up in various places — `event.url` in [hooks](hooks) and [server routes](routing#server), [`$page.url`](modules#$app-stores) in [pages](routing#page), `from` and `to` in [`beforeNavigate` and `afterNavigate`](modules#$app-navigation) and so on.
+
+### URLSearchParams
+
+Wherever you encounter a URL, you can access query parameters via `url.searchParams`, which is an instance of [`URLSearchParams`](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams):
+
+```js
+// @filename: ambient.d.ts
+declare global {
+	const url: URL;
+}
+
+export {};
+
+// @filename: index.js
+// ---cut---
+const foo = url.searchParams.get('foo');
+```
+
+## Web Crypto
+
+The [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) is made available via the `crypto` global. It's used internally for [Content Security Policy](configuration#csp) headers, but you can also use it for things like generating UUIDs:
+
+```js
+const uuid = crypto.randomUUID();
+```

apps/svelte.dev/content/docs/kit/10-getting-started/index.md

@@ -0,0 +1,3 @@
+---
+title: Getting started
+---