@tinacms/astro 0.0.0-00ff25a-20260605030238

package/LICENSE

@@ -0,0 +1,176 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,178 @@
+# @tinacms/astro
+
+The one-stop [TinaCMS](https://tina.io) integration for Astro. Ships:
+
+- A vanilla-Astro **rich-text renderer** that mirrors the React `TinaMarkdown` API — same `content` prop, same `components` map shape, but emits pure HTML with no React in the page tree.
+- The framework-agnostic **`@tinacms/bridge`** re-exported under `@tinacms/astro/bridge` so you only install one package.
+
+> **Adopting in a new project?** Follow the step-by-step [GETTING_STARTED.md](./GETTING_STARTED.md) — covers install (incl. `@tinacms/cli`), integration wiring, data loaders, island registry, and troubleshooting. The rest of this README is the API reference.
+
+## Install
+
+```bash
+pnpm add @tinacms/astro tinacms
+pnpm add -D @tinacms/cli
+```
+
+Requires Astro 5 or 6 and an SSR adapter (`@astrojs/node`, `vercel`, `netlify`, or `cloudflare`) — the island-refresh endpoint (`/tina-island/[name]`) is on-demand. `output: 'server'` is the simplest choice; `output: 'static'` also works as long as editable regions are wrapped in [`<TinaIsland>`](#static-site-editing) and the adapter can serve that one on-demand route.
+
+## Usage
+
+Add the integration to `astro.config.mjs` once. It wires the request-scoped middleware and stages the bundled bridge as a static asset at `/admin/bridge.js` — everything else is auto-injected only on edit-mode requests:
+
+```ts
+// astro.config.mjs
+import { defineConfig } from 'astro/config';
+import tina from '@tinacms/astro/integration';
+
+export default defineConfig({
+  integrations: [tina()],
+});
+```
+
+Then load data the same way you would in any TinaCMS project — call the generated client, wrap the result with `requestWithMetadata()`:
+
+```astro
+---
+import TinaMarkdown from '@tinacms/astro/TinaMarkdown.astro';
+import { requestWithMetadata, tinaField } from '@tinacms/astro';
+import client from '../tina/__generated__/client';
+
+const post = await requestWithMetadata(
+  client.queries.post({ relativePath: 'hello.md' }),
+);
+---
+<article>
+  <h1 data-tina-field={tinaField(post.data.post, 'title')}>
+    {post.data.post.title}
+  </h1>
+  <div data-tina-field={tinaField(post.data.post, '_body')}>
+    <TinaMarkdown content={post.data.post._body} />
+  </div>
+</article>
+```
+
+That's the whole user surface. No wiring component in your layout, no `forms` prop to maintain, no `Astro.request` to thread. The integration's middleware buffers each HTML response, and on edit-mode requests splices the form payloads and a `<script type="module" src="/admin/bridge.js">` before `</head>`. Production visitors get **byte-identical HTML to a Tina-free Astro app** — no `data-tina-form` divs, no script tag, no bundle preload. (Exception: pages that use [`<TinaIsland>`](#static-site-editing) carry a one-line inline bootstrap so editing also works when the page is statically built.)
+
+For cross-origin admin deployments (Codespaces, separate-domain self-hosted), set `PUBLIC_TINA_ADMIN_ORIGIN` in your env (comma-separate to allow multiple). The middleware embeds it inline so the bridge validates inbound `postMessage` events.
+
+## Static-site editing
+
+`output: 'static'` is supported. The middleware described above only runs on on-demand-rendered routes, so on a prerendered page it never injects anything — instead, **`<TinaIsland>` emits a tiny in-iframe bootstrap script** that loads `/admin/bridge.js` *only* when the page is inside the admin iframe (a no-op for everyone else). On boot the bridge "primes" the page by fetching each island's `/tina-island/[name]` endpoint — which is `prerender = false`, so the adapter still renders it on demand — to pick up the page's form payloads, after which editing works exactly as it does in an SSR project.
+
+Requirements for static editing:
+
+- Wrap every editable region in `<TinaIsland>` with a registered island (see [GETTING_STARTED.md](./GETTING_STARTED.md) steps 5–7) — that's both how the bridge re-renders regions and how the bootstrap gets onto the page.
+- Pass `primary` on your page's main `<TinaIsland>` (`<TinaIsland name="post" params={{ slug }} primary>`). On a static page the bridge can't tell which island is "the page", so without this the editor may land on the multi-document "Referenced Files" list when the page also has e.g. a global-config form. (On SSR pages the first `requestWithMetadata()` call is treated as primary automatically; pass `{ priority: 'primary' }` as the second argument if you need to override that.) Mark at most one per page.
+- Keep the `tina-island/[name].ts` route (`export const prerender = false`).
+
+Trade-off: a page that uses `<TinaIsland>` carries that one-line inline bootstrap in its production HTML, so it's no longer byte-identical to a Tina-free Astro app. Pages without `<TinaIsland>` are unaffected. (On `output: 'server'` the middleware path is unchanged; the bootstrap and the middleware's own injection coexist harmlessly — `bridge.init()` is idempotent.)
+
+## Subpath exports
+
+| Subpath | What it gives you |
+|---------|-------------------|
+| `@tinacms/astro` | `requestWithMetadata`, `tinaField`, `QueryResult`, and types |
+| `@tinacms/astro/TinaMarkdown.astro` | `<TinaMarkdown content components />` — rich-text renderer. Import from this subpath so Astro's check sees a real `.astro` component (the bare-package default resolves through the types condition to a placeholder). |
+| `@tinacms/astro/integration` | `tina()` integration — auto-wires the middleware and stages the static `/admin/bridge.js` asset so `requestWithMetadata()` works without you threading `Astro.request` or writing wiring components |
+| `@tinacms/astro/TinaIsland.astro` | `<TinaIsland name wrapper params [primary] />` — marker wrapper for an editable region; pass `primary` on the page's main region so the editor opens that form instead of the "Referenced Files" list |
+| `@tinacms/astro/types` | `TinaRichTextContent`, `CustomComponentsMap`, `TinaRichTextNode`, `MdxElement`, `TextElement` |
+| `@tinacms/astro/sanitize` | `sanitizeHref` / `sanitizeImageSrc` for CMS-supplied URLs |
+| `@tinacms/astro/bridge` | `init`, `refreshForms`, and the rest of `@tinacms/bridge` |
+| `@tinacms/astro/tina-field` | `tinaField()` helper |
+| `@tinacms/astro/is-edit-mode` | `isEditMode(request)` — server-side admin-iframe detection |
+| `@tinacms/astro/middleware` | The middleware the integration auto-wires — exported here in case you need to compose it manually |
+| `@tinacms/astro/vite` | `tinaAdminDevRedirect()` — dev-only Vite plugin that redirects `/admin` and `/admin/` to `/admin/index.html` so the admin SPA is reachable from a bare URL during `astro dev` |
+| `@tinacms/astro/experimental` | `experimental_createIslandRoute()` — opt-in helper built on Astro's unstable `experimental_AstroContainer` |
+
+## Custom MDX components
+
+Register Astro components against the names Tina uses for them in the editor:
+
+```astro
+---
+import TinaMarkdown from '@tinacms/astro/TinaMarkdown.astro';
+import type { CustomComponentsMap } from '@tinacms/astro/types';
+import BlockQuote from '../components/BlockQuote.astro';
+import NewsletterSignup from '../components/NewsletterSignup.astro';
+
+const components: CustomComponentsMap = {
+  BlockQuote,
+  NewsletterSignup,
+};
+---
+<TinaMarkdown content={post.data.post._body} components={components} />
+```
+
+The renderer dispatches `mdxJsxFlowElement` and `mdxJsxTextElement` nodes by `node.name`. Unknown names render a visible placeholder so you spot missing registrations during development.
+
+## Default-tag overrides
+
+The same `components` map can override the default HTML tag a node renders to. Useful for styling without forking the renderer:
+
+```ts
+const components: CustomComponentsMap = {
+  p: Paragraph,        // Tailwind-styled <p>
+  h1: Heading1,
+  blockquote: BlockquoteTag,
+  code_block: CodeBlock, // e.g. shiki-highlighted
+  a: Anchor,
+  img: Img,
+};
+```
+
+Supported override keys: `p`, `h1`–`h6`, `ul`, `ol`, `li`, `blockquote`, `lic`, `a`, `img`, `code_block`, `hr`, `break`.
+
+## Visual editing markers
+
+The renderer doesn't emit `data-tina-field` attributes — wrap the call site to add them at whatever granularity makes sense:
+
+```astro
+---
+import TinaMarkdown from '@tinacms/astro/TinaMarkdown.astro';
+import { tinaField } from '@tinacms/astro/tina-field';
+---
+<div data-tina-field={tinaField(post.data.post, '_body')}>
+  <TinaMarkdown content={post.data.post._body} components={components} />
+</div>
+```
+
+Coarse-grained boundaries (the whole `_body`) are usually what you want — clicking any rich-text node focuses the editor on that field.
+
+## Supported node types
+
+| Type | Default rendering | Override key |
+|------|-------------------|--------------|
+| `p`, `h1`–`h6` | `<p>`, `<h1>`–`<h6>` | same |
+| `ul`, `ol`, `li` | `<ul>`, `<ol>`, `<li>` | same |
+| `blockquote` | `<blockquote>` | `blockquote` |
+| `lic` | `<div>` | `lic` |
+| `a` | `<a href={sanitized}>` | `a` |
+| `img` | `<img src={sanitized}>` | `img` |
+| `code_block` | `<pre><code class="language-…">` | `code_block` |
+| `hr` | `<hr>` | `hr` |
+| `break` | `<br>` | `break` |
+| `text` (with `bold`/`italic`/`underline`/`strikethrough`/`code`/`highlight`) | nested `<strong>`/`<em>`/`<u>`/`<s>`/`<code>`/`<mark>` | n/a |
+| `mdxJsxFlowElement`, `mdxJsxTextElement` | dispatched by `node.name` | n/a — register by name |
+| `html`, `html_inline` | raw HTML via `set:html` | n/a |
+| `invalid_markdown` | `<pre>{value}</pre>` | n/a |
+
+CMS-supplied URLs in `a` and `img` nodes pass through `sanitizeHref` / `sanitizeImageSrc`, blocking `javascript:`, `data:`, `vbscript:`, and protocol-relative URLs. Both helpers are exposed on `@tinacms/astro/sanitize` for use in your own components (e.g. block-level Hero images, navigation anchors).
+
+## Testing
+
+Tests use Astro's [`experimental_AstroContainer`](https://docs.astro.build/en/reference/container-reference/). Fixtures are synced from `@tinacms/mdx`'s parser test corpus so renderer assertions track real editor output.
+
+```bash
+pnpm test
+```
+
+To pull a fresh fixture set after adding a new node type to `@tinacms/mdx`:
+
+```bash
+pnpm sync-fixtures
+```
+
+## License
+
+Apache 2.0

package/dist/bridge.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Re-exports of `@tinacms/bridge` so Astro projects can pull the bridge from
+ * `@tinacms/astro/bridge` instead of installing it separately. The bridge
+ * package stays publishable on its own for non-Astro frontends (Hugo, plain
+ * HTML, Eleventy).
+ */
+export * from '@tinacms/bridge';

package/dist/bridge.js

@@ -0,0 +1,2 @@
+// src/bridge.ts
+export * from "@tinacms/bridge";

package/dist/data.d.ts

@@ -0,0 +1,19 @@
+export interface QueryResult<TData> {
+    data: TData;
+    query: string;
+    variables: Record<string, unknown>;
+    id: string;
+}
+type ClientResult<TData> = {
+    data: TData;
+    query: string;
+    variables: Record<string, unknown>;
+} | null | undefined;
+export interface RequestOptions {
+    /** Mark the page's own document so the admin opens it on load instead
+     *  of a layout-level global. Mirrors `useTina`'s
+     *  `experimental___selectFormByFormId`. */
+    priority?: 'primary';
+}
+export declare function requestWithMetadata<TData>(source: ClientResult<TData> | Promise<ClientResult<TData>>, options?: RequestOptions): Promise<QueryResult<TData>>;
+export {};

package/dist/data.js

@@ -0,0 +1,64 @@
+// src/data.ts
+import { addMetadata, hashFromQuery } from "@tinacms/bridge/metadata";
+import { readOverlay } from "@tinacms/bridge/preview";
+
+// src/internal/forms-store.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var STORE_KEY = Symbol.for("@tinacms/astro/forms-store");
+var slot = globalThis;
+var formsStore = slot[STORE_KEY] ??= new AsyncLocalStorage();
+function recordForm(form) {
+  const list = formsStore.getStore();
+  if (!list) return;
+  const existing = list.find((entry) => entry.id === form.id);
+  if (existing) {
+    if (form.priority === "primary") existing.priority = "primary";
+    return;
+  }
+  list.push(form);
+}
+
+// src/internal/request-context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var STORE_KEY2 = Symbol.for("@tinacms/astro/request-context");
+var slot2 = globalThis;
+var requestStore = slot2[STORE_KEY2] ??= new AsyncLocalStorage2();
+
+// src/data.ts
+async function requestWithMetadata(source, options) {
+  let result = null;
+  try {
+    result = await source ?? null;
+  } catch (error) {
+    console.warn("[@tinacms/astro] client query failed", error);
+  }
+  const query = result?.query ?? "";
+  const variables = result?.variables ?? {};
+  const id = hashFromQuery(JSON.stringify({ query, variables }));
+  const data = result?.data ?? {};
+  const request = requestStore.getStore();
+  let resolvedData = data;
+  if (request) {
+    const overlay = await readOverlay(request, id);
+    if (overlay !== void 0) {
+      resolvedData = overlay;
+    }
+  }
+  const enriched = {
+    data: addMetadata(id, resolvedData),
+    query,
+    variables,
+    id
+  };
+  recordForm({
+    id,
+    query,
+    variables,
+    data: enriched.data,
+    priority: options?.priority
+  });
+  return enriched;
+}
+export {
+  requestWithMetadata
+};

package/dist/data.test-d.d.ts

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

package/dist/experimental.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Experimental surface area. Anything here may change in a minor or
+ * patch release — opt in only when the underlying tradeoff is worth
+ * it for your project.
+ *
+ * `experimental_createIslandRoute` builds on Astro's
+ * `experimental_AstroContainer`, which Astro itself flags as unstable;
+ * this re-export inherits the same caveat.
+ */
+export { experimental_createIslandRoute, type IslandConfig, type IslandRegistry, } from './island-route';

package/dist/experimental.js

@@ -0,0 +1,87 @@
+// src/island-route.ts
+import { PREVIEW_CONTENT_TYPE, PRIME_HEADER } from "@tinacms/bridge/preview";
+import { experimental_AstroContainer as AstroContainer } from "astro/container";
+
+// src/internal/escape.ts
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/internal/forms-store.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var STORE_KEY = Symbol.for("@tinacms/astro/forms-store");
+var slot = globalThis;
+var formsStore = slot[STORE_KEY] ??= new AsyncLocalStorage();
+function sortByPriority(forms) {
+  return [...forms].sort(
+    (a, b) => (a.priority === "primary" ? 0 : 1) - (b.priority === "primary" ? 0 : 1)
+  );
+}
+function renderFormPayloadDiv(form, primary) {
+  return `<div data-tina-form="${escapeAttr(JSON.stringify(form))}"${primary ? " data-tina-primary" : ""} hidden></div>`;
+}
+
+// src/internal/request-context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var STORE_KEY2 = Symbol.for("@tinacms/astro/request-context");
+var slot2 = globalThis;
+var requestStore = slot2[STORE_KEY2] ??= new AsyncLocalStorage2();
+
+// src/island-route.ts
+function experimental_createIslandRoute(islands) {
+  return async ({ params, request, url }) => {
+    const rejection = rejectIfUnsafe(request);
+    if (rejection) return rejection;
+    const island = islands[params.name ?? ""];
+    if (!island) {
+      return new Response(`Unknown island "${params.name}"`, { status: 404 });
+    }
+    const priming = request.headers.get(PRIME_HEADER) !== null;
+    try {
+      const forms = [];
+      const html = await requestStore.run(
+        request,
+        () => formsStore.run(forms, async () => {
+          const data = await island.fetch(request, url.searchParams);
+          const container = await AstroContainer.create();
+          return container.renderToString(island.component, {
+            props: island.propsFromData(data, url.searchParams)
+          });
+        })
+      );
+      const body = (priming ? renderFormPayloads(forms) : "") + wrapIsland(html, island.wrapper, url);
+      return new Response(body, {
+        headers: {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-store"
+        }
+      });
+    } catch {
+      return new Response("Island render failed", { status: 500 });
+    }
+  };
+}
+function rejectIfUnsafe(request) {
+  if (request.method !== "POST") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+  const contentType = request.headers.get("content-type") ?? "";
+  if (!contentType.includes(PREVIEW_CONTENT_TYPE)) {
+    return new Response("Not Found", { status: 404 });
+  }
+  if (request.headers.get("sec-fetch-site") === "cross-site") {
+    return new Response("Forbidden", { status: 403 });
+  }
+  return null;
+}
+function renderFormPayloads(forms) {
+  return sortByPriority(forms).map((form) => renderFormPayloadDiv(form, form.priority === "primary")).join("");
+}
+function wrapIsland(html, wrapper, url) {
+  const cls = wrapper.className ? ` class="${escapeAttr(wrapper.className)}"` : "";
+  const marker = escapeAttr(`${url.pathname}${url.search}`);
+  return `<${wrapper.tag}${cls} data-tina-island="${marker}">${html}</${wrapper.tag}>`;
+}
+export {
+  experimental_createIslandRoute
+};

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Runtime entry for the package's `.` subpath. Astro consumers resolve
+ * through the `astro` export condition straight to `src/TinaMarkdown.astro`
+ * — they get the real component as the default export plus the named
+ * helpers re-exported from the .astro frontmatter.
+ *
+ * This file is the fallback for any tool that *doesn't* understand the
+ * `astro` condition (TypeScript types, plain Node ESM resolution). It
+ * exposes the named runtime helpers and a placeholder default that
+ * throws with a clear redirect if someone reaches it.
+ */
+import type { AstroComponentFactory } from 'astro/runtime/server/index.js';
+import type { CustomComponentsMap, TinaRichTextContent } from './types';
+export { requestWithMetadata, type QueryResult } from './data';
+export { tinaField } from './tina-field';
+export type { AstroComponent, CustomComponentsMap, MdxElement, TextElement, TinaRichTextContent, TinaRichTextNode, TinaRichTextRoot, } from './types';
+/**
+ * Typed shape of `<TinaMarkdown content={...} components={...} />` for tools
+ * that resolve through the `types` / `default` export condition rather than
+ * the `astro` condition. The actual component is `src/TinaMarkdown.astro`;
+ * this placeholder throws if invoked because the only legitimate caller is
+ * Astro's component pipeline, which reaches the .astro file directly.
+ *
+ * The intersection of `AstroComponentFactory` (Astro's component-validity
+ * check) and a typed prop signature (TinaMarkdown's actual API) gives the
+ * Astro language server enough shape to both recognise this as a renderable
+ * component AND offer prop completions / type errors at the call site.
+ */
+type TinaMarkdownComponent = AstroComponentFactory & {
+    (props: {
+        content: TinaRichTextContent;
+        components?: CustomComponentsMap;
+    }): unknown;
+};
+declare const TinaMarkdownPlaceholder: TinaMarkdownComponent;
+export default TinaMarkdownPlaceholder;