@strifeapp/astro 1.0.27 → 1.0.29

package/README.md

@@ -0,0 +1,90 @@
+# @strifeapp/astro - RECOVERED SOURCE CODE
+
+This source code was recovered from the compiled distribution package v1.0.27.
+
+## ⚠️ Important Notes
+
+1. **ImageService**: The `src/services/ImageService.ts` file only had type definitions in the compiled version. The actual implementation needs to be filled in based on your requirements.
+
+2. **indexMapping.js**: This file should NOT be converted to TypeScript as it runs inside RavenDB's JavaScript indexing engine. Keep it as plain JavaScript.
+
+3. **Module References**: The vite plugin reads `indexMapping.js` at build time using `readFileSync`, so make sure the path resolution in `vite-plugin-strife-store.ts` is correct for your build setup.
+
+## Structure
+
+```
+src/
+├── index.ts                           # Main Astro integration export
+├── vite-plugin-strife-store.ts        # Vite plugin for virtual module
+├── vite-plugin-strife-store-entry.ts  # Entry point for standalone plugin export
+├── env.ts                              # Environment variable loader
+├── indexMapping.js                     # RavenDB index mapping functions (JavaScript!)
+└── services/
+    └── ImageService.ts                 # Image service (needs implementation)
+```
+
+## Building
+
+```bash
+npm install
+npm run build
+```
+
+This will compile TypeScript and generate type definitions in the `dist/` folder.
+
+## Environment Variables
+
+Required environment variables:
+
+- `STRIFE_DATABASE_URLS` - Comma-separated list of RavenDB URLs
+- `STRIFE_DATABASE` - Database name
+- `STRIFE_CERTIFICATE` - Base64-encoded PFX certificate (optional for development)
+- `STRIFE_CERTIFICATE_PASSWORD` - Certificate password (optional for development)
+
+## Usage
+
+In your Astro project:
+
+```typescript
+import { defineConfig } from 'astro/config';
+import strifeIntegration from '@strifeapp/astro';
+
+export default defineConfig({
+  integrations: [
+    strifeIntegration({
+      // Optional: Override environment variables
+      urls: ['https://your-ravendb.com'],
+      database: 'your-database',
+      collections: [
+        { name: 'Posts' },
+        { name: 'Pages' },
+      ],
+    }),
+  ],
+});
+```
+
+## What This Integration Does
+
+1. **Connects to RavenDB** using environment variables or provided config
+2. **Deploys a search index** called `Content_ByUrl` for content search
+3. **Indexes documents** from specified collections (default: Posts)
+4. **Creates a virtual module** `strife:store` that exports the RavenDB DocumentStore
+5. **Bulk inserts templates** into the Templates collection
+
+## Recovery Process
+
+The source was recovered by:
+
+1. Analyzing the minified compiled output
+2. Identifying variable names and function patterns
+3. Extracting the embedded index mapping source code
+4. Reconstructing TypeScript types from `.d.ts` files
+5. Reverse engineering the build configuration
+
+## Next Steps
+
+- [ ] Implement the ImageService if needed
+- [ ] Verify the build output matches the original
+- [ ] Add tests
+- [ ] Update version number if making changes

package/dist/index.d.ts

@@ -12,3 +12,4 @@ export interface Collection {
     [key: string]: any;
 }
 export default function strifeIntegration(options?: IntegrationOptions): AstroIntegration;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAI5C,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAMD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,gBAAgB,CAsCxF"}

package/dist/index.js

@@ -1,371 +1,30 @@
-import { loadEnv as f } from "vite";
-import d from "serialize-javascript";
-const y = `/**
- * Creates an indexed item that will be stored in the index.
- * @param {string} name - Name of property to index
- * @param {any} value - Value to index and store
- * @returns a new object to index and store
- */
-function storeAs(name, value) {
-    return {
-      $value: value,
-      $name: name,
-      $options: { storage: true },
-    };
-  }
-
-  /**
-   * Create an indexed item without storing value in the index.
-   * @param {string} name - Name of the property to index
-   * @param {any} value - The value to index
-   * @returns a new object to index (no store)
-   */
-  function indexAs(name, value) {
-    return {
-      $value: value,
-      $name: name,
-      $options: { storage: false },
-    };
-  }
-
-  /**
-   * Loads the documents referenced by reference objects in the array
-   * @param {any} references - Array of document references: { id, collection }
-   * @returns The list of loaded documents.
-   */
-  function loadRelatedDocuments(references) {
-    if (references == null) return null;
-    return references
-      .filter((item) => typeof item.id === 'string') // Ensure each ID is a string
-      .map((item) => load(item.id, 'Labels'))
-      .filter(Boolean); // Filter out any null/undefined values
-  }
-
-  /**
-   * Builds an url for a document by traversing its ancestor origins
-   * @param {*} doc - The leaf document
-   * @returns The full url of the document
-   */
-  function buildUrl(doc) {
-    const visited = {};
-    const slugs = [];
-    let c = doc;
-
-    do {
-      if (c.slug) {
-        slugs.unshift(c.slug);
-      }
-      if (!c.origin || visited[c.origin.id]) break;
-      visited[c.origin.id] = true;
-      c = load(c.origin.id, c.origin.collection);
-    } while (c);
-
-    return slugs.shift() + slugs.join('/');
-  }
-
-  /**
-   * Editor types that contains {collection, id} references that we want to load
-   */
-  const RELATION_EDITORS = ['related', 'references'];
-
-  /**
-   * Loads the template document of the specified document
-   * @param {any} document - The document to index
-   * @returns The document's template, loaded
-   */
-  function loadTemplate(document) {
-    const collection = document['@metadata']['@collection'];
-    const template = load('templates/' + collection, 'templates');
-    return template;
-  }
-
-  /**
-   * Loads the metadata template
-   * @returns The metadata template
-   */
-  function loadMetadataTemplate() {
-    const template = load('templates/metadata', 'templates');
-    return template;
-  }
-
-  /**
-   * Iterates the template's editors and copies the respective values to the
-   * result object. Properties containing references are resolved recursively.
-   * Mutually recursive with \`loadRelatedDocumentsRecurse\`.
-   * @param {*} document - The document to extract values from
-   * @param {*} template - The document's template
-   * @param {*} metadataTemplate - The metadata template
-   * @param {*} result - The populated result
-   */
-  function populateValuesByEditor(document, template, metadataTemplate, result, loadedDocs) {
-    const aggregatedEditors = template.editors.concat(metadataTemplate.editors);
-    // Add dynamic fields and handle "related" type
-    aggregatedEditors.forEach((editor) => {
-      if (editor.editor && editor.editor.propertyName) {
-        const propertyName = editor.editor.propertyName;
-
-        if (RELATION_EDITORS.includes(editor.editor.type) && Array.isArray(document[propertyName])) {
-          // Load related documents in the array of document references
-          const relatedDocs = loadRelatedDocumentsRecurse(document[propertyName], metadataTemplate, loadedDocs);
-          result[propertyName] = relatedDocs;
-        } else if (editor.editor.type === 'content-template') {
-          const content = document[propertyName];
-          if (content) {
-            const contentTemplate = load(editor.editor.attributes.templateId, 'templates');
-            const docResult = {};
-            populateValuesByEditor(content, contentTemplate, metadataTemplate, docResult, loadedDocs);
-            result[propertyName] = docResult;
-          }
-        } else if (editor.editor.type === 'chapters') {
-          const chapters = document[propertyName];
-          if (chapters && Array.isArray(chapters)) {
-            const docResults = [];
-            chapters.forEach((chapter) => {
-              if (chapter['@strife'] && chapter['@strife'].templateId) {
-                const docResult = {};
-                const chaptersTemplate = load(chapter['@strife'].templateId, 'templates');
-                populateValuesByEditor(chapter, chaptersTemplate, metadataTemplate, docResult, loadedDocs);
-                docResults.push(docResult);
-              }
-            });
-            result[propertyName] = docResults;
-          }
-        } else if (document[propertyName] !== undefined) {
-          // For other types, index the field value directly
-          result[propertyName] = document[propertyName];
-        }
-      }
-    });
-    if (document['@strife']) {
-      result['@strife'] = document['@strife'];
-    }
-  }
-
-  /**
-   * Loads the documents referenced by the array of references. Mutually recursive
-   * with \`populateValuesByEditor\`.
-   * @param {*} references - List of references to load.
-   * @returns
-   */
-  function loadRelatedDocumentsRecurse(references, metadataTemplate, loadedDocs) {
-    if (references == null) return null;
-    const documents = references
-      .map((id) => (typeof id === 'string' ? id : id.id))
-      .map((id) => {
-        if (loadedDocs.has(id)) return null;
-
-        const aDoc = load(id, '@all_docs');
-
-        if (aDoc) {
-          loadedDocs.add(id);
-        }
-        return aDoc;
-      })
-      .filter(Boolean); // Filter out any null/undefined values
-
-    const docResults = [];
-    documents.forEach((doc) => {
-      const template = loadTemplate(doc);
-      const docResult = {
-        id: Id(doc),
-        url: buildUrl(doc),
-        collection: doc['@metadata']['@collection'],
-        labels: loadRelatedDocuments(
-          doc.labels.map((l) => {
-            return { id: l, collection: 'Labels' };
-          }),
-        ),
-      };
-      populateValuesByEditor(doc, template, metadataTemplate, docResult, loadedDocs);
-      docResults.push(docResult);
-    });
-
-    return docResults;
-  }
-
-  /**
-   * Maps a document to an index entry for Strife's content index
-   * @param {any} document - The document to index
-   * @returns An object to be indexed by RavenDB
-   */
-  function mapDocument(document) {
-    const collection = document['@metadata']['@collection'];
-    const template = load('templates/' + collection, 'templates');
-
-    if (!template || !template.editors || document.deleted || document.archived) {
-      return null;
-    }
-
-    const metadataTemplate = loadMetadataTemplate();
-
-    // Initialize result with static fields
-    const result = {
-      id: Id(document),
-      displayName: document.displayName,
-      url: storeAs('url', buildUrl(document)),
-      origin: document.origin,
-      collection: storeAs('collection', collection),
-      publishedDate: storeAs('publishedAt', document.publishedDate),
-      createdAt: storeAs('createdAt', document.createdAt),
-      changedAt: storeAs('changedAt', document.changedAt),
-      labels: storeAs(
-        'labels',
-        loadRelatedDocuments(
-          document.labels.map((l) => {
-            return { id: l, collection: 'Labels' };
-          }),
-        ),
-      ),
-      deleted: document.deleted,
-    };
-
-    // Keep tabs of loaded documents to avoid infinite recursion
-    const loadedDocuments = new Set(result.id);
-
-    // Add dynamic fields and handle "related" type
-    template.editors.forEach((editor) => {
-      if (editor.editor && editor.editor.propertyName) {
-        const propertyName = editor.editor.propertyName;
-
-        if (RELATION_EDITORS.includes(editor.editor.type) && Array.isArray(document[propertyName])) {
-          // Load related documents in the array of document references
-          const relatedDocs = loadRelatedDocumentsRecurse(document[propertyName], metadataTemplate, loadedDocuments);
-          result[propertyName] = storeAs(propertyName, relatedDocs);
-        } else if (editor.editor.type === 'content-template') {
-          const content = document[propertyName];
-          if (content) {
-            const template = load(editor.editor.attributes.templateId, 'templates');
-            const docResult = {};
-            populateValuesByEditor(content, template, metadataTemplate, docResult, loadedDocuments);
-            result[propertyName] = storeAs(propertyName, docResult);
-          }
-        } else if (editor.editor.type === 'chapters') {
-          const chapters = document[propertyName];
-          if (chapters && Array.isArray(chapters)) {
-            const docResults = [];
-            chapters.forEach((chapter) => {
-              if (chapter['@strife'] && chapter['@strife'].templateId) {
-                const docResult = {};
-                const template = load(chapter['@strife'].templateId, 'templates');
-                populateValuesByEditor(chapter, template, metadataTemplate, docResult, loadedDocuments);
-                docResults.push(docResult);
-              }
-            });
-            result[propertyName] = storeAs(propertyName, docResults);
-          }
-        } else if (document[propertyName] !== undefined) {
-          // For other types, index the field value directly
-          result[propertyName] = indexAs(propertyName, document[propertyName]);
-        }
-      }
-    });
-
-    return result;
-  }`, m = "strife:store", p = "\0" + m;
-function h(e) {
-  return {
-    name: "strife:store",
-    resolveId(s) {
-      if (s === m)
-        return p;
-    },
-    load(s) {
-      var o;
-      if (s === p)
-        return `
-          import { DocumentStore, AbstractJavaScriptMultiMapIndexCreationTask } from "ravendb";
-
-          ${e.certificate && e.password ? `
-          const authOptions = {
-            type: 'pfx',
-            certificate: Buffer.from(${d(e.certificate)}, 'base64'),
-            password: ${d(e.password)},
-          };
-          ` : ""}
-
-          const store = new DocumentStore(
-            ${d(e.urls ? e.urls : [])},
-            ${d(e.database || "")}${e.certificate && e.password ? `,
-            authOptions` : ""}
-          ).initialize()
-
-          class Content_ByUrl extends AbstractJavaScriptMultiMapIndexCreationTask {
-            constructor() {
-              super();
-
-              this.additionalSources = {"Helper": ${d(y)}}
-
-              ${(e.collections || ["Posts"]).map((t) => `this.map("${typeof t == "string" ? t : t.name}", (doc) =>  { return mapDocument(doc) });`).join(`
-`)}
-
-              this.deploymentMode = 'Rolling';
-              this.searchEngineType = 'Lucene';
-            }
-          }
-
-          console.log('Deploying index...');
-
-          await store.executeIndex(new Content_ByUrl());
-
-          const bulkInsert = store.bulkInsert();
-
-          ${(o = e.collections) == null ? void 0 : o.map((t) => `
-            await bulkInsert.store(${JSON.stringify(t)}, 'templates/${t.name}', { '@collection': 'Templates' });
-          `).join(`
-`)}
-
-          await bulkInsert.finish();
-
-          export { store };
-        `;
-    }
-  };
-}
-const T = {
+import { v as _ } from "./vite-plugin-strife-store-HEEze8Mw.js";
+import { loadEnv as l } from "vite";
+const a = {
   type: "pfx"
 };
-function R(e, s) {
-  let o = process.env.STRIFE_DATABASE_URLS, t = process.env.STRIFE_DATABASE, r = process.env.STRIFE_CERTIFICATE, l = process.env.STRIFE_CERTIFICATE_PASSWORD;
-  if (!o || !t || !r || !l) {
-    const n = f(e, s ?? "", "");
-    o = o || n.STRIFE_DATABASE_URLS, t = t || n.STRIFE_DATABASE, r = r || n.STRIFE_CERTIFICATE, l = l || n.STRIFE_CERTIFICATE_PASSWORD;
-  }
-  return console.log("[strifeIntegration] Loaded environment variables:"), console.log(`  STRIFE_DATABASE_URLS: ${o ? "[SET]" : "[NOT SET]"}`), console.log(`  STRIFE_DATABASE: ${t || "[NOT SET]"}`), console.log(`  STRIFE_CERTIFICATE: ${r ? `[SET, length=${r.length}]` : "[NOT SET]"}`), console.log(`  STRIFE_CERTIFICATE_PASSWORD: ${l ? "[SET]" : "[NOT SET]"}`), {
-    urls: o ? o.split(",").map((n) => n.trim()).filter(Boolean) : void 0,
-    database: t || void 0,
-    certificate: r || void 0,
-    password: l || void 0
-  };
-}
-function v(e) {
+function d(e) {
   return {
     name: "@strife/astro",
     hooks: {
-      "astro:config:setup": ({ command: s, config: o, updateConfig: t }) => {
-        const r = o.vite.envDir || process.cwd(), l = R(s, r), n = {
-          ...T,
-          ...Object.fromEntries(
-            Object.entries(l).filter(([a, i]) => !!i)
-          ),
+      "astro:config:setup": ({ config: c, updateConfig: f }) => {
+        const E = c.vite.envDir || process.cwd(), { STRIFE_CERTIFICATE: t, STRIFE_CERTIFICATE_PASSWORD: T, STRIFE_DATABASE_URLS: r, STRIFE_DATABASE: S } = l(process.env.NODE_ENV ?? "", E, "");
+        e = {
+          ...e,
+          certificate: t ?? (e == null ? void 0 : e.certificate) ?? a.certificate,
+          password: T ?? (e == null ? void 0 : e.password),
+          urls: r ? r.split(",") : (e == null ? void 0 : e.urls) ?? [],
+          database: S ?? (e == null ? void 0 : e.database)
+        };
+        const A = {
+          ...a,
           ...e ? Object.fromEntries(
-            Object.entries(e).filter(([a, i]) => !!i)
+            Object.entries(e).filter(([u, I]) => !!I)
           ) : {}
-        }, c = ["urls", "database"], u = c.filter(
-          (a) => !n[a] || Array.isArray(n[a]) && n[a].length === 0
-        );
-        if (u.length > 0)
-          throw new Error(
-            `[strifeIntegration] Missing required environment variables: ${u.join(", ")}.
-Set them in your .env file (for local) or Vercel project settings (for deployment).
-Current values:
-` + c.map((a) => `  ${a}: ${JSON.stringify(n[a])}`).join(`
-`)
-          );
-        t({
+        };
+        f({
           vite: {
-            plugins: [
-              h(n)
-            ]
+            plugins: [_(A)]
           }
         });
       }
@@ -373,5 +32,5 @@ Current values:
   };
 }
 export {
-  v as default
+  d as default
 };

package/dist/localized-content-index.js

@@ -0,0 +1,587 @@
+/**
+ * -----------------------------------------------------------------------------
+ *  STRIFE CONTENT INDEX — L10N + StrifeUri + Template-Aware Relations
+ * -----------------------------------------------------------------------------
+ * What this does
+ *   Projects Strife CMS documents into a query‑friendly, localized, relation‑expanded
+ *   shape with one entry per locale. It keeps a deterministic output and a
+ *   centralized storage policy (Corax‑safe).
+ *   Cycle safety and performance caching.
+ *
+ * Canonical root fields (unchanged semantics)
+ *   - id, locale, displayName, url, origin, collection
+ *   - publishedAt, createdAt, changedAt, dependencies, labels, deleted
+ *
+ * Root template (whitelist + localizable)
+ *   - Root fields are populated from the document's template. Scalars marked
+ *     localizable are translated using the current entry's locale and stored.
+ *   - Non‑localizable scalars are index‑only at root.
+ *   - Arrays/objects (relations, chapters, content objects) are stored.
+ *   - Reserved root names can never be redefined by editors.
+ *
+ * Relations (template‑driven for referenced docs)
+ *   - Relations are detected by value shape (array of GUIDs or { id: GUID }).
+ *   - For each referenced GUID, the target document is loaded and projected with
+ *     its template (resolved by collection), using the ROOT entry's locale for
+ *     any localizable scalars.
+ *   - Order is preserved. Only GUIDs are followed. Cycles are prevented via a
+ *     visit cache.
+ *
+ * Nested content by shape (no template loads)
+ *   - Chapters: arrays of small objects; expanded recursively by shape.
+ *   - Content‑template (object): expanded recursively by shape.
+ *   - While expanding by shape, if a field is a relation array by shape, those
+ *     relations are projected via templates (same as above). Otherwise, values
+ *     are copied through. No per‑field localization occurs in shape expansion.
+ *
+ * StrifeUri
+ *   - Form: strife://<docId>.<collection>.<db>/<path>
+ *   - Resolution: loads the target doc and walks the path; the first path
+ *     segment is localized with the ROOT entry's locale. The resolved value can be:
+ *       • a scalar → copied as is
+ *       • an object/array → expanded by shape
+ *       • a relation array → projected via templates
+ *
+ * Storage policy (centralized at root copy step)
+ *   - Arrays/objects → storeAs
+ *   - Scalars localizable at root → storeAs (so projections return translated strings)
+ *   - Scalars not localizable → indexAs (leaner index)
+ *   - Root url is always stored
+ *   - Keep per‑field storage/analyzer consistent across documents (Corax‑safe)
+ *
+ * Caching & cycle safety
+ *   - docCache: documents, tplCache: templates, labelCache: labels
+ *   - visit cache prevents cycles and provides memoization per entry
+ *   - URL builder protects against origin cycles via a local visited set
+ *
+ * Localization model
+ *   - Emits one entry per configured locale.
+ *   - Root scalars marked localizable are translated and stored.
+ *   - Referenced docs projected via templates also translate localizable scalars
+ *     using the ROOT locale. displayName is treated as non‑localized.
+ *   - Shape expansion itself does not localize values, except StrifeUri's first
+ *     path segment at dereference time.
+ *
+ * Determinism & engine constraints
+ *   - ES5‑only (no for..of, no arrow functions).
+ *   - Deterministic shapes under the same inputs.
+ *   - No performance guards (depth/breadth are unbounded); cycles are still safe.
+ * -----------------------------------------------------------------------------
+ */
+
+
+var RESERVED_ROOT_FIELDS = {
+  url: true,
+  collection: true,
+  publishedAt: true,
+  createdAt: true,
+  changedAt: true,
+  labels: true,
+  locale: true,
+  origin: true,
+  id: true,
+  displayName: true,
+  dependencies: true
+};
+
+function storeAs(name, value) {
+  return { $value: value, $name: name, $options: { storage: true } };
+}
+
+function indexAs(name, value) {
+  return { $value: value, $name: name, $options: { storage: false } };
+}
+
+function loadDocCached(id, collection, docCache) {
+  if (!id) return null;
+  var key = collection + '::' + id;
+  if (docCache.has(key)) return docCache.get(key);
+  var d = load(id, collection);
+  if (d) docCache.set(key, d);
+  return d;
+}
+
+function loadTemplateByCollectionCached(collection, tplCache) {
+  if (!collection) return null;
+  var key = 'templates/' + collection;
+  if (tplCache.has(key)) return tplCache.get(key);
+  var t = load(key, 'templates');
+  if (t) tplCache.set(key, t);
+  return t;
+}
+
+function loadTemplateByIdCached(templateId, tplCache) {
+  if (!templateId) return null;
+  var key = templateId;
+  if (tplCache.has(key)) return tplCache.get(key);
+  var t = load(templateId, 'templates');
+  if (t) tplCache.set(key, t);
+  return t;
+}
+
+function loadLocalizationSettings() {
+  return load('configurations/localization', 'configurations');
+}
+
+function loadLabelCached(id, labelCache) {
+  if (!id) return null;
+  if (labelCache.has(id)) return labelCache.get(id);
+  var d = load(id, 'Labels');
+  if (d) labelCache.set(id, d);
+  return d;
+}
+
+function buildUrlCached(doc, docCache) {
+  var visited = {};
+  var slugs = [];
+  var c = doc;
+  do {
+    if (c.slug) slugs.unshift(c.slug);
+    if (!c.origin || visited[c.origin.id]) break;
+    visited[c.origin.id] = true;
+    c = loadDocCached(c.origin.id, c.origin.collection, docCache);
+  } while (c);
+
+  return slugs.shift() + slugs.join('/');
+}
+
+function getTranslator(locale, defaultLocale, fallbackToPrimary) {
+  return function (obj) {
+    if (!obj) return null;
+    if (typeof obj === 'object' && obj.hasOwnProperty) {
+      if (obj.hasOwnProperty(locale)) return obj[locale];
+      // if (fallbackToPrimary && locale && locale.length > 2) {
+      //   var base = locale.slice(0, 2);
+      //   if (obj.hasOwnProperty(base)) return obj[base];
+      // }
+      //return obj[defaultLocale];
+    }
+    return null;
+  };
+}
+
+function isGuid(s) {
+  return typeof s === 'string' &&
+         /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(s);
+}
+function isRefLike(x) {
+  // GUID string id, or object with GUID `id`
+  if (typeof x === 'string') return isGuid(x);
+  if (!x || typeof x !== 'object') return false;
+  return typeof x.id === 'string' && isGuid(x.id) && Object.keys(x).length <= 2;
+}
+function isRelationArray(v) {
+  if (!v || !Array.isArray(v)) return false;
+  if (v.length === 0) return false; // empty arrays are ambiguous
+  for (var i = 0; i < v.length; i++) {
+    if (!isRefLike(v[i])) return false;
+  }
+  return true;
+}
+
+var strifeUriPattern = /^strife:\/\/(?<id>[-\w_]*)\.(?<coll>[\w_-]*)\.(?<db>[\w_-]*)(?<path>[-\w_./]*)?$/;
+function isStrifeUri(value) {
+  var match = strifeUriPattern.exec(value || '');
+  if (!match) return null;
+  try {
+    var path = match.groups.path || '';
+    var segs = path.length > 1 ? path.slice(1).split('/') : [];
+    return {
+      original: value,
+      db: match.groups.db,
+      collection: match.groups.coll,
+      docId: match.groups.id,           // may be non-GUID by design for StrifeUri
+      segments: segs
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+function tryGetReferencedValue(strifeUri, populationContext, docCache) {
+  var document = loadDocCached(strifeUri.docId, '@all_docs', docCache);
+  if (!document) return null;
+
+  var val = document;
+  if (strifeUri.segments.length > 0) {
+    // first segment may be localized
+    var first = strifeUri.segments[0];
+    val = populationContext.translate(val[first]);
+    for (var i = 1; i < strifeUri.segments.length; i++) {
+      if (val == null) break;
+      var segment = strifeUri.segments[i];
+      val = val[segment];
+    }
+  }
+  return val;
+}
+
+function resolveStrifeUriIfAny(value, populationContext, docCache) {
+  var maybeUri = isStrifeUri(value);
+  return maybeUri ? tryGetReferencedValue(maybeUri, populationContext, docCache) : value;
+}
+
+function loadRelatedLabels(labelIdsArray, labelCache) {
+  if (!labelIdsArray || !labelIdsArray.length) return null;
+  var out = [];
+  for (var i = 0; i < labelIdsArray.length; i++) {
+    var lid = labelIdsArray[i];
+    var d = loadLabelCached(lid, labelCache);
+    if (d) out.push(d);
+  }
+  return out;
+}
+
+function getVisitEntry(visit, id) {
+  var e = visit.get(id);
+  if (!e) { e = { state: 'done', node: null }; visit.set(id, e); }
+  return e;
+}
+
+function isVisiting(visit, id) {
+  var e = visit.get(id);
+  return e ? e.state === 'visiting' : false;
+}
+
+function markVisiting(visit, id) {
+  var e = getVisitEntry(visit, id);
+  e.state = 'visiting';
+}
+
+function markDone(visit, id) {
+  var e = getVisitEntry(visit, id);
+  e.state = 'done';
+}
+
+function getCachedNode(visit, id) {
+  var e = visit.get(id);
+  return e && e.node ? e.node : null;
+}
+
+function setCachedNode(visit, id, node) {
+  var e = getVisitEntry(visit, id);
+  e.node = node;
+}
+
+function isContentTemplateNode(v) {
+  return v && typeof v === 'object' && !Array.isArray(v) &&
+         v['@strife'] && v['@strife'].template;
+}
+
+function isChaptersArray(v) {
+  if (!v || !Array.isArray(v)) return false;
+  if (v.length === 0) return false;
+  for (var i = 0; i < v.length; i++) {
+    var it = v[i];
+    if (!it || !it['@strife'] || !it['@strife'].template) return false;
+  }
+  return true;
+}
+
+function populateByShape(document, out, populationContext, visit,
+                         docCache, tplCache, labelCache) {
+  if (!document || typeof document !== 'object') return;
+
+  for (var prop in document) {
+    if (!document || !document.hasOwnProperty || !document.hasOwnProperty(prop)) continue;
+
+    // Keep metadata decorations as-is
+    if (prop.charAt(0) === '@') { out[prop] = document[prop]; continue; }
+
+    var val = document[prop];
+    // StrifeUri resolution
+    val = resolveStrifeUriIfAny(val, populationContext, docCache);
+
+    // Chapters
+    if (isChaptersArray(val)) {
+      var arr = [];
+      for (var ci = 0; ci < val.length; ci++) {
+        var chapter = val[ci];
+        if (chapter && chapter['@strife'] && chapter['@strife'].template) {
+          var child = {};
+          populateByShape(chapter, child, populationContext, visit,
+                          docCache, tplCache, labelCache);
+          arr.push(child);
+        }
+      }
+      out[prop] = arr;
+      continue;
+    }
+
+    // Content-template node
+    if (isContentTemplateNode(val)) {
+      var nested = {};
+      populateByShape(val, nested, populationContext, visit,
+                      docCache, tplCache, labelCache);
+      out[prop] = nested;
+      continue;
+    }
+
+    // Relations (GUID-strict)
+    if (isRelationArray(val)) {
+      var related = projectRelationsIfAny(val, populationContext, visit, docCache, tplCache, labelCache);
+      if (related) { out[prop] = related; continue; }
+    }
+
+    // Default: copy-through (no localization inside nested)
+    out[prop] = val;
+  }
+
+  if (document['@strife'] && !out['@strife']) out['@strife'] = document['@strife'];
+}
+
+function projectRelationsIfAny(value, populationContext, visit, docCache, tplCache, labelCache) {
+  if (!isRelationArray(value)) return null;
+  var refs = [];
+  for (var i = 0; i < value.length; i++) {
+    var v = value[i];
+    var idStr = (typeof v === 'string') ? v : (v && v.id);
+    if (isGuid(idStr)) refs.push(idStr);
+  }
+  return loadRelatedDocumentsRecurse(refs, populationContext, visit, docCache, tplCache, labelCache);
+}
+
+function populateValuesByEditor(document, template, result, populationContext, visit,
+                                docCache, tplCache, labelCache, isRootLevel) {
+  if (!template || !template.editors) return;
+  var tEditors = template.editors || [];
+  var i, editor;
+
+  function processEditor(editor, isRoot) {
+    if (!editor || !editor.editor || !editor.editor.propertyName) return;
+
+    var propertyName = editor.editor.propertyName;
+
+    // Never let editors redefine reserved fields (consistent everywhere)
+    if (RESERVED_ROOT_FIELDS[propertyName]) return;
+
+    // Read value with optional localization
+    var rawVal = document[propertyName];
+    var docValue = (editor.localizable) ? populationContext.translate(rawVal) : rawVal;
+
+    // StrifeUri resolution
+    docValue = resolveStrifeUriIfAny(docValue, populationContext, docCache);
+
+    // Relations (GUID-strict) — detect by value shape
+    var relatedDocs = projectRelationsIfAny(docValue, populationContext, visit, docCache, tplCache, labelCache);
+    if (relatedDocs) { result[propertyName] = relatedDocs; return; }
+
+    // Chapters (nested without template loads)
+    if (editor.editor.type === 'chapters') {
+      if (docValue == null) {                // missing translation
+        result[propertyName] = null;         // keep null instead of dropping field
+        return;
+      }
+      if (!Array.isArray(docValue)) return;
+      var docResults = [];
+      for (var ci = 0; ci < docValue.length; ci++) {
+        var chapter = docValue[ci];
+        if (chapter && chapter['@strife'] && chapter['@strife'].template) {
+          var child = {};
+          populateByShape(chapter, child, populationContext, visit,
+                          docCache, tplCache, labelCache);
+          docResults.push(child);
+        }
+      }
+      result[propertyName] = docResults;
+      return;
+    }
+
+    // Content-template (nested without template loads)
+    if (editor.editor.type === 'content-template') {
+      if (docValue == null) {                // missing translation
+        result[propertyName] = null;
+        return;
+      }
+      if (docValue && typeof docValue === 'object') {
+        var nested = {};
+        populateByShape(docValue, nested, populationContext, visit,
+                        docCache, tplCache, labelCache);
+        result[propertyName] = nested;
+      }
+      return;
+    }
+
+    // Other fields: plain values (localized at root when editor.localizable)
+    if (docValue !== undefined) {
+      result[propertyName] = docValue;
+    }
+  }
+
+  for (i = 0; i < tEditors.length; i++) {
+    processEditor(tEditors[i], isRootLevel);
+  }
+
+  if (document['@strife']) result['@strife'] = document['@strife'];
+}
+
+function projectDocumentWithTemplate(doc, populationContext, visit,
+                                     docCache, tplCache, labelCache) {
+  var collection = doc && doc['@metadata'] ? doc['@metadata']['@collection'] : null;
+  var tpl = loadTemplateByCollectionCached(collection, tplCache);
+  var labelsArr = Array.isArray(doc.labels) ? doc.labels : null;
+
+  var result = {
+    id: Id(doc),
+    url: buildUrlCached(doc, docCache),
+    collection: collection,
+    displayName: doc.displayName,
+    slug: doc.slug,
+    publishedDate: doc.publishedDate,
+    labels: loadRelatedLabels(labelsArr, labelCache)
+  };
+
+  // Fill fields per template (use root locale via populationContext.translate)
+  if (tpl && tpl.editors) {
+    populateValuesByEditor(doc, tpl, result, populationContext, visit,
+                           docCache, tplCache, labelCache, false);
+  }
+
+  return result;
+}
+
+function loadRelatedDocumentsRecurse(refGuids, populationContext, visit,
+                                     docCache, tplCache, labelCache) {
+  if (!refGuids) return null;
+
+  var results = [];
+  for (var i = 0; i < refGuids.length; i++) {
+    var id = refGuids[i];
+    if (!isGuid(id)) continue;
+
+    if (isVisiting(visit, id)) continue;
+
+    var cached = getCachedNode(visit, id);
+    if (cached) { results.push(cached); continue; }
+
+    markVisiting(visit, id);
+    var doc = loadDocCached(id, '@all_docs', docCache);
+
+    if (doc) {
+      var projected = projectDocumentWithTemplate(doc, populationContext, visit,
+                                                 docCache, tplCache, labelCache);
+      setCachedNode(visit, id, projected);
+      results.push(projected);
+    }
+
+    markDone(visit, id);
+  }
+
+  return results;
+}
+
+function mapDocument(document) {
+  var collection = document['@metadata']['@collection'];
+  var template = load('templates/' + collection, 'templates');
+  if (!template || !template.editors || document.deleted || document.archived) return null;
+
+  var l10n = loadLocalizationSettings();
+  var locales = (l10n && Array.isArray(l10n.locales)) ? l10n.locales : [l10n && l10n.defaultLocale ? l10n.defaultLocale : 'en'];
+
+  // Shared per-document caches (shared across locales)
+  var _docCache   = new Map();
+  var _tplCache   = new Map();
+  var _labelCache = new Map();
+
+  var entries = [];
+
+  // Precompute root labels (loaded in helper)
+  var rootLabelIds = Array.isArray(document.labels) ? document.labels : null;
+
+  // Precompute dependencies (ES5)
+  var depsArr = [];
+  if (document.dependencies && Array.isArray(document.dependencies)) {
+    for (var di = 0; di < document.dependencies.length; di++) {
+      var dep = document.dependencies[di];
+      if (dep && typeof dep.id === 'string') depsArr.push(dep.id);
+    }
+  }
+
+  // Build a set of localizable root scalar fields from the template
+  var localizableRoot = {};
+  if (template && template.editors) {
+    for (var li0 = 0; li0 < template.editors.length; li0++) {
+      var ed0 = template.editors[li0];
+      if (!ed0 || !ed0.editor || !ed0.editor.propertyName) continue;
+      var t0 = ed0.editor.type;
+      if (t0 !== 'related' && t0 !== 'references' && t0 !== 'content-template' && t0 !== 'chapters') {
+        if (ed0.localizable === true) localizableRoot[ed0.editor.propertyName] = true;
+      }
+    }
+  }
+
+  for (var li = 0; li < locales.length; li++) {
+
+    var currentLocale = locales[li];
+    if (document.locales && Array.isArray(document.locales)) {
+      var found = false;
+      for (var k = 0; k < document.locales.length; k++) {
+        if (document.locales[k] === currentLocale) { found = true; break; }
+      }
+      if (!found) continue;
+    }
+
+    var translate = getTranslator(currentLocale, l10n.defaultLocale, l10n.fallbackToPrimary);
+
+    // Root result (stored fields)
+    var result = {
+      id: Id(document),
+      locale: storeAs('locale', currentLocale),
+      displayName: document.displayName,
+      url: template.disableURL ? null : storeAs('url', buildUrlCached(document, _docCache)),
+      origin: storeAs('origin', document.origin ? document.origin.id : null ),
+      collection: storeAs('collection', collection),
+      publishedDate: storeAs('publishedAt', document.publishedDate),
+      createdAt: storeAs('createdAt', document.createdAt),
+      changedAt: storeAs('changedAt', document.changedAt),
+      dependencies: storeAs('dependencies', depsArr),
+      //labels: storeAs('labels', loadRelatedLabels(rootLabelIds, _labelCache)),
+      labels: storeAs('labels', loadRelatedLabels(rootLabelIds, _labelCache).map(label => label.name)),
+      deleted: document.deleted
+    };
+
+    // Visit cache per-locale (keeps shapes deterministic per entry)
+    var visit = new Map();
+
+    // Build dynamic fields into a temp container using ROOT TEMPLATE (respect localizable)
+    var rootContainer = {};
+    populateValuesByEditor(document, template, rootContainer, { translate: translate },
+                           visit, _docCache, _tplCache, _labelCache, true);
+
+    // Copy fields from temp container into result
+    // - arrays/objects -> storeAs
+    // - scalars -> storeAs if localizable, else indexAs
+    var keys = [];
+    for (var key in rootContainer) {
+      if (rootContainer && rootContainer.hasOwnProperty && rootContainer.hasOwnProperty(key)) {
+        keys.push(key);
+      }
+    }
+
+    for (var ei = 0; ei < keys.length; ei++) {
+      var prop = keys[ei];
+
+      // never redefine canonical root fields
+      if (RESERVED_ROOT_FIELDS[prop]) continue;
+
+      var val = rootContainer[prop];
+      var isArray = Array.isArray(val);
+      var isProjectedArray  = isArray && (val.length === 0 || typeof val[0] === 'object');
+      var isProjectedObject = !isArray && typeof val === 'object';
+
+      if (isProjectedArray || isProjectedObject) {
+        result[prop] = storeAs(prop, val);
+      } else {
+        if (localizableRoot[prop] === true) {
+          result[prop] = storeAs(prop, val);   // translated scalar → store so projections return translated value
+        } else {
+          result[prop] = indexAs(prop, val);   // non-localizable scalar → index-only
+        }
+      }
+    }
+
+    entries.push(result);
+  }
+
+  return entries;
+}

package/dist/services/ImageService.d.ts

@@ -1,3 +1,4 @@
 import { ImageService } from 'astro';
 declare const service: ImageService;
 export default service;
+//# sourceMappingURL=ImageService.d.ts.map

package/dist/services/ImageService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageService.d.ts","sourceRoot":"","sources":["../../src/services/ImageService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAI1C,QAAA,MAAM,OAAO,EAAE,YAGP,CAAC;AAET,eAAe,OAAO,CAAC"}

package/dist/vite-plugin-strife-store-HEEze8Mw.js

@@ -0,0 +1,73 @@
+import { readFileSync as c } from "fs";
+import { dirname as m, resolve as u } from "path";
+import { fileURLToPath as d } from "url";
+import r from "serialize-javascript";
+const n = "strife:store", o = "\0" + n;
+function S(e) {
+  const i = d(import.meta.url), p = m(i), l = c(
+    u(p, "./localized-content-index.js"),
+    "utf-8"
+  );
+  return {
+    name: "strife:store",
+    resolveId(s) {
+      if (s === n)
+        return o;
+    },
+    load(s) {
+      var a;
+      if (s === o)
+        return `
+          import { DocumentStore, AbstractJavaScriptMultiMapIndexCreationTask } from "ravendb";
+
+          ${e.certificate && e.password ? `
+          const authOptions = {
+            type: 'pfx',
+            certificate: Buffer.from(${r(e.certificate)}, 'base64'),
+            password: ${r(e.password)},
+          };
+          ` : ""}
+
+          const store = new DocumentStore(
+            ${r(e.urls ? e.urls : [])},
+            ${r(e.database || "")}${e.certificate && e.password ? `,
+            authOptions` : ""}
+          ).initialize()
+
+          class Content_ByUrl extends AbstractJavaScriptMultiMapIndexCreationTask {
+            constructor() {
+              super();
+
+              this.additionalSources = {"Helper": ${r(l)}}
+
+              ${(e.collections || ["Posts"]).map(
+          (t) => `this.map("${typeof t == "string" ? t : t.name}", (doc) =>  { return mapDocument(doc) });`
+        ).join(`
+`)}
+
+              this.deploymentMode = 'Rolling';
+              this.searchEngineType = 'Lucene';
+            }
+          }
+
+          console.log('Deploying index...');
+
+          await store.executeIndex(new Content_ByUrl());
+
+          const bulkInsert = store.bulkInsert();
+
+          ${(a = e.collections) == null ? void 0 : a.map((t) => `
+            await bulkInsert.store(${JSON.stringify(t)}, 'templates/${t.name}', { '@collection': 'Templates' });
+          `).join(`
+`)}
+
+          await bulkInsert.finish();
+
+          export { store };
+        `;
+    }
+  };
+}
+export {
+  S as v
+};

package/dist/vite-plugin-strife-store-entry.d.ts

@@ -1 +1,6 @@
-export * from './vite-plugin-strife-store';
+/**
+ * Entry point for importing the vite plugin directly
+ * Usage: import { vitePluginStrifeStore } from '@strifeapp/astro/vite-plugin-strife-store'
+ */
+export { vitePluginStrifeStore } from './vite-plugin-strife-store';
+//# sourceMappingURL=vite-plugin-strife-store-entry.d.ts.map

package/dist/vite-plugin-strife-store-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-strife-store-entry.d.ts","sourceRoot":"","sources":["../src/vite-plugin-strife-store-entry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/vite-plugin-strife-store-entry.js

@@ -0,0 +1,4 @@
+import { v as t } from "./vite-plugin-strife-store-HEEze8Mw.js";
+export {
+  t as vitePluginStrifeStore
+};

package/dist/vite-plugin-strife-store.d.ts

@@ -1,3 +1,4 @@
-import { IntegrationOptions } from './index';
 import { PluginOption } from 'vite';
+import { IntegrationOptions } from './index';
 export declare function vitePluginStrifeStore(config: IntegrationOptions): PluginOption;
+//# sourceMappingURL=vite-plugin-strife-store.d.ts.map

package/dist/vite-plugin-strife-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-strife-store.d.ts","sourceRoot":"","sources":["../src/vite-plugin-strife-store.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAEzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAKlD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CAmE9E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strifeapp/astro",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "description": "Official Strife Astro integration",
   "keywords": [
     "astro-integration",
@@ -29,24 +29,19 @@
   ],
   "dependencies": {
     "astro": "^4.0.0 || ^5.0.0",
-    "dotenv": "^16.4.5",
-    "ravendb": "^5.4.3",
+    "dotenv": "^17.2.3",
+    "ravendb": "^7.1.4",
     "serialize-javascript": "^6.0.2"
   },
   "devDependencies": {
     "@types/dotenv": "^8.2.0",
+    "@types/serialize-javascript": "^5.0.4",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
-    "vite": "^6.2.1",
+    "vite": "^6.4.1",
     "vite-plugin-dts": "^4.5.3"
   },
   "peerDependencies": {
-    "astro": "^4.0.0 || ^5.0.0",
-    "ravendb": "^5.4.3"
-  },
-  "compilerOptions": {
-    "declaration": true,
-    "emitDeclarationOnly": false,
-    "outDir": "dist"
+    "astro": "^4.0.0 || ^5.0.0"
   }
 }