@glw907/cairn-cms 0.5.1 → 0.6.0-rc.1

package/dist/auth/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/lib/auth/schema.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBf,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBnB,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BnB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBxB,CAAC;AAEF,eAAO,MAAM,aAAa;;;EAGvB,CAAC;AAEJ,eAAO,MAAM,gBAAgB;;EAK1B,CAAC;AAEJ,eAAO,MAAM,gBAAgB;;EAK1B,CAAC"}

package/dist/auth/schema.js

@@ -1,93 +0,0 @@
-import { relations, sql } from "drizzle-orm";
-import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core";
-export const user = sqliteTable("user", {
-    id: text("id").primaryKey(),
-    name: text("name").notNull(),
-    email: text("email").notNull().unique(),
-    emailVerified: integer("email_verified", { mode: "boolean" })
-        .default(false)
-        .notNull(),
-    image: text("image"),
-    createdAt: integer("created_at", { mode: "timestamp_ms" })
-        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
-        .notNull(),
-    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
-        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
-        .$onUpdate(() => /* @__PURE__ */ new Date())
-        .notNull(),
-    role: text("role"),
-    banned: integer("banned", { mode: "boolean" }).default(false),
-    banReason: text("ban_reason"),
-    banExpires: integer("ban_expires", { mode: "timestamp_ms" }),
-});
-export const session = sqliteTable("session", {
-    id: text("id").primaryKey(),
-    expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
-    token: text("token").notNull().unique(),
-    createdAt: integer("created_at", { mode: "timestamp_ms" })
-        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
-        .notNull(),
-    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
-        .$onUpdate(() => /* @__PURE__ */ new Date())
-        .notNull(),
-    ipAddress: text("ip_address"),
-    userAgent: text("user_agent"),
-    userId: text("user_id")
-        .notNull()
-        .references(() => user.id, { onDelete: "cascade" }),
-    impersonatedBy: text("impersonated_by"),
-}, (table) => [index("session_userId_idx").on(table.userId)]);
-export const account = sqliteTable("account", {
-    id: text("id").primaryKey(),
-    accountId: text("account_id").notNull(),
-    providerId: text("provider_id").notNull(),
-    userId: text("user_id")
-        .notNull()
-        .references(() => user.id, { onDelete: "cascade" }),
-    accessToken: text("access_token"),
-    refreshToken: text("refresh_token"),
-    idToken: text("id_token"),
-    accessTokenExpiresAt: integer("access_token_expires_at", {
-        mode: "timestamp_ms",
-    }),
-    refreshTokenExpiresAt: integer("refresh_token_expires_at", {
-        mode: "timestamp_ms",
-    }),
-    scope: text("scope"),
-    password: text("password"),
-    createdAt: integer("created_at", { mode: "timestamp_ms" })
-        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
-        .notNull(),
-    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
-        .$onUpdate(() => /* @__PURE__ */ new Date())
-        .notNull(),
-}, (table) => [index("account_userId_idx").on(table.userId)]);
-export const verification = sqliteTable("verification", {
-    id: text("id").primaryKey(),
-    identifier: text("identifier").notNull(),
-    value: text("value").notNull(),
-    expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
-    createdAt: integer("created_at", { mode: "timestamp_ms" })
-        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
-        .notNull(),
-    updatedAt: integer("updated_at", { mode: "timestamp_ms" })
-        .default(sql `(cast(unixepoch('subsecond') * 1000 as integer))`)
-        .$onUpdate(() => /* @__PURE__ */ new Date())
-        .notNull(),
-}, (table) => [index("verification_identifier_idx").on(table.identifier)]);
-export const userRelations = relations(user, ({ many }) => ({
-    sessions: many(session),
-    accounts: many(account),
-}));
-export const sessionRelations = relations(session, ({ one }) => ({
-    user: one(user, {
-        fields: [session.userId],
-        references: [user.id],
-    }),
-}));
-export const accountRelations = relations(account, ({ one }) => ({
-    user: one(user, {
-        fields: [account.userId],
-        references: [user.id],
-    }),
-}));

package/dist/carta.d.ts

@@ -1,39 +0,0 @@
-import type { Pluggable, Processor } from 'unified';
-export interface PreviewPlugins {
-    /** remark plugins, injected after gfm and before remark-rehype. */
-    remarkPlugins: Pluggable[];
-    /** rehype plugins, injected after remark-rehype. */
-    rehypePlugins: Pluggable[];
-}
-interface PreviewTransformer {
-    execution: 'sync';
-    type: 'remark' | 'rehype';
-    transform: (ctx: {
-        processor: Processor;
-    }) => void;
-}
-/**
- * Map the site's plugin set to Carta sync transformers, remark phase before rehype.
- * Carta's processor is remarkParse → gfm → [remark] → remark-rehype → [rehype] → stringify,
- * so this ordering reproduces render.ts exactly. Pure (no Carta) so it is unit-testable.
- */
-export declare function previewTransformers({ remarkPlugins, rehypePlugins }: PreviewPlugins): PreviewTransformer[];
-/** Minimal Options subset we populate (avoids importing carta-md, which re-exports Svelte components). */
-interface PreviewCartaOptions {
-    sanitizer: false;
-    rehypeOptions: {
-        allowDangerousHtml: boolean;
-    };
-    extensions: Array<{
-        transformers: PreviewTransformer[];
-    }>;
-}
-/**
- * Carta options for a render-only preview: site plugins wired in, raw HTML allowed, no
- * sanitizer. Authors are trusted and the directive pipeline emits intentional raw HTML
- * (render.ts uses allowDangerousHtml + rehype-raw); sanitizing here would strip EC
- * primitives. The Svelte component passes this to `new Carta(...)`.
- */
-export declare function previewCartaOptions(plugins: PreviewPlugins): PreviewCartaOptions;
-export {};
-//# sourceMappingURL=carta.d.ts.map

package/dist/carta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"carta.d.ts","sourceRoot":"","sources":["../src/lib/carta.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,aAAa,EAAE,SAAS,EAAE,CAAC;IAC3B,oDAAoD;IACpD,aAAa,EAAE,SAAS,EAAE,CAAC;CAC5B;AAED,UAAU,kBAAkB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,SAAS,EAAE,CAAC,GAAG,EAAE;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE,KAAK,IAAI,CAAC;CACpD;AAYD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,aAAa,EAAE,aAAa,EAAE,EAAE,cAAc,GAAG,kBAAkB,EAAE,CAE1G;AAED,0GAA0G;AAC1G,UAAU,mBAAmB;IAC3B,SAAS,EAAE,KAAK,CAAC;IACjB,aAAa,EAAE;QAAE,kBAAkB,EAAE,OAAO,CAAA;KAAE,CAAC;IAC/C,UAAU,EAAE,KAAK,CAAC;QAAE,YAAY,EAAE,kBAAkB,EAAE,CAAA;KAAE,CAAC,CAAC;CAC3D;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,GAAG,mBAAmB,CAMhF"}

package/dist/carta.js

@@ -1,30 +0,0 @@
-function phase(plugins, type) {
-    return plugins.map((plugin) => ({
-        execution: 'sync',
-        type,
-        transform: ({ processor }) => {
-            processor.use([plugin]);
-        },
-    }));
-}
-/**
- * Map the site's plugin set to Carta sync transformers, remark phase before rehype.
- * Carta's processor is remarkParse → gfm → [remark] → remark-rehype → [rehype] → stringify,
- * so this ordering reproduces render.ts exactly. Pure (no Carta) so it is unit-testable.
- */
-export function previewTransformers({ remarkPlugins, rehypePlugins }) {
-    return [...phase(remarkPlugins, 'remark'), ...phase(rehypePlugins, 'rehype')];
-}
-/**
- * Carta options for a render-only preview: site plugins wired in, raw HTML allowed, no
- * sanitizer. Authors are trusted and the directive pipeline emits intentional raw HTML
- * (render.ts uses allowDangerousHtml + rehype-raw); sanitizing here would strip EC
- * primitives. The Svelte component passes this to `new Carta(...)`.
- */
-export function previewCartaOptions(plugins) {
-    return {
-        sanitizer: false,
-        rehypeOptions: { allowDangerousHtml: true },
-        extensions: [{ transformers: previewTransformers(plugins) }],
-    };
-}

package/dist/components/CollectionList.svelte

@@ -1,96 +0,0 @@
-<script lang="ts">
-  // One collection's entries: a table (title, date, draft badge) linking into the editor, plus a
-  // collapsible "New entry" form. The author types a title; the slug stem derives from it (R4) and
-  // stays editable. A story collection also collects a date, which createEntry forwards so the new
-  // entry opens with its date set. Placeholders differ by kind. The shell (AdminLayout) owns the
-  // chrome and nav; this renders only the body.
-  import type { CollectionListData } from '../sveltekit';
-  import { slugify } from '../slug';
-
-  let { data }: { data: CollectionListData } = $props();
-
-  let title = $state('');
-  let slug = $state('');
-  let slugEdited = $state(false);
-
-  // Keep the slug in sync with the title until the author edits the slug directly.
-  function onTitleInput(value: string) {
-    title = value;
-    if (!slugEdited) slug = slugify(value);
-  }
-
-  const slugPlaceholder = $derived(data.kind === 'page' ? 'about-us' : '2026-05-my-entry');
-</script>
-
-<div class="flex items-center justify-between gap-4">
-  <h1 class="text-2xl font-bold">{data.label}</h1>
-  {#if data.canCreate}
-    <details class="dropdown dropdown-end">
-      <summary class="btn btn-primary btn-sm">New entry</summary>
-      <form
-        method="POST"
-        action="?/create"
-        class="dropdown-content z-10 mt-2 flex w-80 flex-col gap-2 rounded-box border border-base-300 bg-base-100 p-4 shadow"
-      >
-        <label class="flex flex-col gap-1">
-          <span class="text-sm font-medium">Title</span>
-          <input
-            type="text"
-            value={title}
-            oninput={(e) => onTitleInput(e.currentTarget.value)}
-            placeholder="A human title"
-            class="input w-full"
-          />
-        </label>
-
-        {#if data.kind === 'story'}
-          <label class="flex flex-col gap-1">
-            <span class="text-sm font-medium">Date</span>
-            <input type="date" name="date" class="input w-full" />
-          </label>
-        {/if}
-
-        <label class="flex flex-col gap-1">
-          <span class="text-sm font-medium">Slug</span>
-          <input
-            type="text"
-            name="id"
-            required
-            bind:value={slug}
-            oninput={() => (slugEdited = true)}
-            placeholder={slugPlaceholder}
-            pattern="[a-z0-9]([a-z0-9-]*[a-z0-9])?"
-            class="input w-full"
-          />
-          <span class="text-xs opacity-60">Lowercase letters, numbers, and hyphens. Becomes the filename.</span>
-        </label>
-
-        <button type="submit" class="btn btn-primary btn-sm">Create &amp; edit</button>
-      </form>
-    </details>
-  {/if}
-</div>
-
-{#if data.formError}
-  <div class="alert alert-error mt-4"><span>{data.formError}</span></div>
-{/if}
-
-{#if data.error}
-  <div class="alert alert-warning mt-6">Couldn't load {data.label.toLowerCase()}: {data.error}</div>
-{:else if data.entries.length === 0}
-  <p class="mt-6 opacity-60">No entries yet.</p>
-{:else}
-  <ul class="menu mt-6 rounded-box border border-base-300 bg-base-100 p-2">
-    {#each data.entries as entry (entry.path)}
-      <li>
-        <a href="/admin/edit/{data.type}/{entry.id}" class="flex items-center justify-between gap-3">
-          <span class="flex items-center gap-2">
-            <span>{entry.title}</span>
-            {#if entry.draft}<span class="badge badge-warning badge-sm">Draft</span>{/if}
-          </span>
-          {#if entry.date}<span class="text-xs opacity-60">{entry.date}</span>{/if}
-        </a>
-      </li>
-    {/each}
-  </ul>
-{/if}

package/dist/components/CollectionList.svelte.d.ts

@@ -1,8 +0,0 @@
-import type { CollectionListData } from '../sveltekit';
-type $$ComponentProps = {
-    data: CollectionListData;
-};
-declare const CollectionList: import("svelte").Component<$$ComponentProps, {}, "">;
-type CollectionList = ReturnType<typeof CollectionList>;
-export default CollectionList;
-//# sourceMappingURL=CollectionList.svelte.d.ts.map

package/dist/components/CollectionList.svelte.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CollectionList.svelte.d.ts","sourceRoot":"","sources":["../../src/lib/components/CollectionList.svelte.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGtD,KAAK,gBAAgB,GAAI;IAAE,IAAI,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAiFvD,QAAA,MAAM,cAAc,sDAAwC,CAAC;AAC7D,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AACxD,eAAe,cAAc,CAAC"}

package/dist/components/ManageAdmins.svelte

@@ -1,84 +0,0 @@
-<script lang="ts">
-  // Owner-gated editor management: list the allowlist, change roles, remove editors, add new
-  // ones. Reuses the same neutral DaisyUI chrome as the rest of the admin (panels, alerts,
-  // table, buttons). Data comes from `adminsLoad` merged with `adminLayoutLoad` (siteName);
-  // mutations post to the page's named form actions (`?/add`, `?/remove`, `?/setRole`).
-  import type { AdminsData } from '../auth';
-
-  interface Props {
-    data: AdminsData & { siteName: string };
-  }
-  let { data }: Props = $props();
-</script>
-
-<svelte:head>
-  <title>Editors · {data.siteName} CMS</title>
-</svelte:head>
-
-<div>
-  <h1 class="text-2xl font-bold">Editors</h1>
-  <p class="text-sm opacity-60">Who can sign in to {data.siteName} CMS.</p>
-</div>
-
-{#if data.saved}
-  <div class="alert alert-success mt-6"><span>Allowlist updated.</span></div>
-{:else if data.error}
-  <div class="alert alert-error mt-6"><span>{data.error}</span></div>
-{/if}
-
-<div class="mt-6 overflow-x-auto rounded-box border border-base-300 bg-base-100">
-  <table class="table">
-    <thead>
-      <tr><th>Name</th><th>Email</th><th>Role</th><th class="text-right">Actions</th></tr>
-    </thead>
-    <tbody>
-      {#each data.admins as admin (admin.email)}
-        {@const isSelf = admin.email === data.self}
-        <tr>
-          <td class="font-medium">{admin.name}</td>
-          <td class="opacity-70">{admin.email}{#if isSelf}<span class="ml-1 opacity-50">(you)</span>{/if}</td>
-          <td>
-            <span class="badge {admin.role === 'owner' ? 'badge-primary' : 'badge-ghost'}">{admin.role}</span>
-          </td>
-          <td>
-            <div class="flex justify-end gap-2">
-              <!-- Flip role. Disabled for yourself so you can't demote the last owner out. -->
-              <form method="POST" action="?/setRole">
-                <input type="hidden" name="email" value={admin.email} />
-                <input type="hidden" name="role" value={admin.role === 'owner' ? 'editor' : 'owner'} />
-                <button type="submit" class="btn btn-ghost btn-xs" disabled={isSelf}>
-                  Make {admin.role === 'owner' ? 'editor' : 'owner'}
-                </button>
-              </form>
-              <form method="POST" action="?/remove">
-                <input type="hidden" name="email" value={admin.email} />
-                <button type="submit" class="btn btn-ghost btn-xs text-error" disabled={isSelf}>Remove</button>
-              </form>
-            </div>
-          </td>
-        </tr>
-      {/each}
-    </tbody>
-  </table>
-</div>
-
-<form method="POST" action="?/add"
-  class="mt-8 grid gap-4 rounded-box border border-base-300 bg-base-100 p-6 sm:grid-cols-[1fr_1fr_auto_auto] sm:items-end">
-  <label class="flex flex-col gap-1">
-    <span class="text-sm font-medium">Email</span>
-    <input type="email" name="email" required autocomplete="off" placeholder="you@example.com"
-      class="input w-full" />
-  </label>
-  <label class="flex flex-col gap-1">
-    <span class="text-sm font-medium">Name</span>
-    <input type="text" name="name" required placeholder="Display name" class="input w-full" />
-  </label>
-  <label class="flex flex-col gap-1">
-    <span class="text-sm font-medium">Role</span>
-    <select name="role" class="select">
-      <option value="editor">editor</option>
-      <option value="owner">owner</option>
-    </select>
-  </label>
-  <button type="submit" class="btn btn-primary">Add editor</button>
-</form>

package/dist/components/ManageAdmins.svelte.d.ts

@@ -1,10 +0,0 @@
-import type { AdminsData } from '../auth';
-interface Props {
-    data: AdminsData & {
-        siteName: string;
-    };
-}
-declare const ManageAdmins: import("svelte").Component<Props, {}, "">;
-type ManageAdmins = ReturnType<typeof ManageAdmins>;
-export default ManageAdmins;
-//# sourceMappingURL=ManageAdmins.svelte.d.ts.map

package/dist/components/ManageAdmins.svelte.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ManageAdmins.svelte.d.ts","sourceRoot":"","sources":["../../src/lib/components/ManageAdmins.svelte.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGxC,UAAU,KAAK;IACb,IAAI,EAAE,UAAU,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CACzC;AAmFH,QAAA,MAAM,YAAY,2CAAwC,CAAC;AAC3D,KAAK,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACpD,eAAe,YAAY,CAAC"}

package/dist/content.d.ts

@@ -1,3 +0,0 @@
-/** Serialize frontmatter data + markdown body back into a file string. */
-export declare function serializeMarkdown(frontmatter: object, body: string): string;
-//# sourceMappingURL=content.d.ts.map

package/dist/content.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../src/lib/content.ts"],"names":[],"mappings":"AAOA,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3E"}

package/dist/content.js

@@ -1,10 +0,0 @@
-// cairn-core: reassemble a markdown file from frontmatter + body for committing.
-//
-// The inverse of the gray-matter parse the edit loader does on read. Kept as its own seam
-// so a site adapter can own the on-disk serialization contract (quoting, key order)
-// without the save endpoint reaching for gray-matter directly.
-import matter from 'gray-matter';
-/** Serialize frontmatter data + markdown body back into a file string. */
-export function serializeMarkdown(frontmatter, body) {
-    return matter.stringify(body, frontmatter);
-}

package/dist/editor.d.ts

@@ -1,25 +0,0 @@
-interface CartaInput {
-    getSelection(): {
-        start: number;
-        end: number;
-        direction: string;
-        slice: string;
-    };
-    insertAt(position: number, text: string): void;
-}
-interface CartaLike {
-    input?: CartaInput;
-}
-/** The programmatic editing surface the admin relies on. */
-export interface MarkdownEditor {
-    /** Insert a component or template at the current cursor position. */
-    insertComponent(template: string): void;
-}
-/**
- * Wrap a Carta instance as a MarkdownEditor. Takes a getter (not the instance) because the
- * EditPage component creates the Carta instance once and `carta.input` is only populated after
- * the editor mounts; reading it lazily at call time avoids capturing an undefined `input`.
- */
-export declare function cartaEditor(getCarta: () => CartaLike): MarkdownEditor;
-export {};
-//# sourceMappingURL=editor.d.ts.map

package/dist/editor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../src/lib/editor.ts"],"names":[],"mappings":"AAQA,UAAU,UAAU;IAClB,YAAY,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAChD;AAED,UAAU,SAAS;IACjB,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAED,4DAA4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,SAAS,GAAG,cAAc,CASrE"}

package/dist/editor.js

@@ -1,20 +0,0 @@
-// cairn-core: the editor cursor seam (decision P3). The component palette and any later insert
-// control talk to MarkdownEditor, never to Carta directly, so a swap to a different editing
-// engine is contained to this file. Verified against carta-md@4.11: `input.getSelection()` and
-// `input.insertAt(pos, text)` are public on the InputEnhancer.
-/**
- * Wrap a Carta instance as a MarkdownEditor. Takes a getter (not the instance) because the
- * EditPage component creates the Carta instance once and `carta.input` is only populated after
- * the editor mounts; reading it lazily at call time avoids capturing an undefined `input`.
- */
-export function cartaEditor(getCarta) {
-    return {
-        insertComponent(template) {
-            const input = getCarta().input;
-            if (!input)
-                return; // editor not mounted yet; nothing to insert into
-            const { start } = input.getSelection();
-            input.insertAt(start, template);
-        },
-    };
-}

package/dist/frontmatter.d.ts

@@ -1,3 +0,0 @@
-/** A frontmatter date value (Date or string) to the `YYYY-MM-DD` an `<input type="date">` expects. */
-export declare function dateInputValue(value: unknown): string;
-//# sourceMappingURL=frontmatter.d.ts.map

package/dist/frontmatter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../src/lib/frontmatter.ts"],"names":[],"mappings":"AAMA,sGAAsG;AACtG,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CASrD"}

package/dist/frontmatter.js

@@ -1,16 +0,0 @@
-// cairn-core: coerce a frontmatter value to the YYYY-MM-DD string an <input type="date"> wants.
-// gray-matter parses an unquoted YAML date (date: 2026-05-14) into a JS Date, so a string-only
-// read leaves the date input empty and drops the date on save. This normalizes a Date or an
-// ISO-ish string to YYYY-MM-DD. A parsed YAML date is UTC midnight, so slicing the ISO string
-// avoids a local-timezone shift. Internal (not re-exported from the barrel), like utils.ts.
-/** A frontmatter date value (Date or string) to the `YYYY-MM-DD` an `<input type="date">` expects. */
-export function dateInputValue(value) {
-    if (value instanceof Date) {
-        return Number.isNaN(value.getTime()) ? '' : value.toISOString().slice(0, 10);
-    }
-    if (typeof value === 'string') {
-        const match = value.match(/^\d{4}-\d{2}-\d{2}/);
-        return match ? match[0] : '';
-    }
-    return '';
-}

package/dist/github.d.ts

@@ -1,72 +0,0 @@
-export interface RepoRef {
-    owner: string;
-    repo: string;
-    branch: string;
-}
-/** A markdown file in a collection directory. `id` is the slug (filename without `.md`). */
-export interface RepoFile {
-    id: string;
-    name: string;
-    path: string;
-}
-/** Build the contents-API URL for a repo path, pinned to the configured branch. */
-export declare function contentsUrl(repo: RepoRef, path: string): string;
-interface ContentsEntry {
-    name: string;
-    path: string;
-    type: string;
-}
-/** Keep only markdown files from a contents-API directory listing, newest id first. */
-export declare function markdownFiles(entries: ContentsEntry[]): RepoFile[];
-/** List the markdown files in a collection directory. */
-export declare function listMarkdown(repo: RepoRef, dir: string, token?: string): Promise<RepoFile[]>;
-/** Fetch a file's raw markdown, or null if it does not exist. */
-export declare function readRaw(repo: RepoRef, path: string, token?: string): Promise<string | null>;
-/** Mint a GitHub App JWT (RS256), valid ~9 min, with `iat` backdated for clock skew. */
-export declare function appJwt(appId: string, privateKeyPem: string): Promise<string>;
-export interface AppCredentials {
-    appId: string;
-    installationId: string;
-    /** The stored GITHUB_APP_PRIVATE_KEY_B64: base64 of the PEM, single line. */
-    privateKeyB64: string;
-}
-/** Exchange the App JWT for a short-lived installation access token. */
-export declare function installationToken(creds: AppCredentials): Promise<string>;
-/** The current blob sha for a path, or null if the file does not yet exist. */
-export declare function fileSha(repo: RepoRef, path: string, token: string): Promise<string | null>;
-export interface CommitAuthor {
-    name: string;
-    email: string;
-}
-/**
- * A concurrent edit lost the SHA race (C3): the file changed between the read and the PUT,
- * from another editor or the site's own CI. Thrown so callers can fail safe (re-fetch and ask
- * the editor to reapply) instead of surfacing a raw 409. Defined and caught inside the package
- * so `instanceof` is reliable (no peer-boundary identity split, unlike kit's `redirect`/`error`).
- */
-export declare class CommitConflictError extends Error {
-    readonly path: string;
-    constructor(path: string);
-}
-/**
- * Commit `content` to `path` on the configured branch via the contents API. Author is the
- * editor; committer is omitted so GitHub attributes it to the App (cairn-cms[bot]). Updates
- * the file in place when it exists (passing its sha), creates it otherwise. Returns the
- * commit sha. A stale-sha 409 (someone committed in between) becomes a `CommitConflictError`.
- */
-export declare function commitFile(repo: RepoRef, path: string, content: string, opts: {
-    message: string;
-    author: CommitAuthor;
-}, token: string): Promise<string>;
-/**
- * Deploy-time self-test for the GitHub App signer (M2): sign a dummy JWT with the configured
- * private key. Exercises the brittle PKCS#1→PKCS#8 conversion + Web Crypto import/sign without
- * any network call or secret in the result, so `/admin/healthz` catches a bad/rotated key
- * before an editor's save fails. Returns `{ ok: false, detail }` rather than throwing.
- */
-export declare function signingSelfTest(appId: string, privateKeyB64: string): Promise<{
-    ok: boolean;
-    detail?: string;
-}>;
-export {};
-//# sourceMappingURL=github.d.ts.map

package/dist/github.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../src/lib/github.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,4FAA4F;AAC5F,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAcD,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG/D;AAED,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,QAAQ,EAAE,CAKlE;AAED,yDAAyD;AACzD,wBAAsB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAIlG;AAED,iEAAiE;AACjE,wBAAsB,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAKjG;AAqCD,wFAAwF;AACxF,wBAAsB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAclF;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wEAAwE;AACxE,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ9E;AAOD,+EAA+E;AAC/E,wBAAsB,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAKhG;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;aAChB,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAIzC;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,EAC/C,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAQrH"}