@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/platform/published-content-pipeline/list-markdown-files.js

@@ -1,181 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { basename, extname, join, resolve } from "node:path";
-import { parseFrontmatterDocument } from "../../content/frontmatter.js";
-import { inferStatus, inferSummary, inferTitle, inferVisibility, markdownText, normalizeRelativeMarkdownPath, normalizeSlug, objectInputForJson } from "./resolve-publication-access-mode.js";
-function listMarkdownFiles(rootPath) {
-  if (!existsSync(rootPath)) {
-    return [];
-  }
-  const stats = statSync(rootPath);
-  if (stats.isFile()) {
-    return rootPath.endsWith(".md") || rootPath.endsWith(".mdx") ? [rootPath] : [];
-  }
-  return readdirSync(rootPath, { withFileTypes: true }).flatMap((entry) => {
-    const fullPath = join(rootPath, entry.name);
-    if (entry.isDirectory()) {
-      return listMarkdownFiles(fullPath);
-    }
-    if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
-      return [fullPath];
-    }
-    return [];
-  }).sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
-}
-class FilesystemContentSource {
-  constructor(tenantConfig) {
-    this.tenantConfig = tenantConfig;
-  }
-  tenantConfig;
-  async listEntries() {
-    const entries = [];
-    for (const [model, rootPath] of Object.entries(this.tenantConfig.content ?? {})) {
-      if (!rootPath) continue;
-      for (const filePath of listMarkdownFiles(String(rootPath))) {
-        const relativePath = normalizeRelativeMarkdownPath(filePath, String(rootPath));
-        const raw = readFileSync(filePath, "utf8");
-        const parsed = parseFrontmatterDocument(raw);
-        const searchText = markdownText(parsed.body);
-        const slug = normalizeSlug(model, relativePath, parsed.frontmatter);
-        entries.push({
-          model,
-          id: basename(filePath, extname(filePath)),
-          slug,
-          title: inferTitle(relativePath, parsed.frontmatter),
-          summary: inferSummary(parsed.frontmatter, searchText),
-          status: inferStatus(parsed.frontmatter),
-          visibility: inferVisibility(parsed.frontmatter),
-          frontmatter: parsed.frontmatter,
-          body: parsed.body,
-          relativePath,
-          filePath,
-          updatedAt: statSync(filePath).mtime.toISOString()
-        });
-      }
-    }
-    return entries;
-  }
-}
-class DefaultEntryRenderer {
-  async render(entry, context) {
-    const contentPayload = {
-      model: entry.model,
-      id: entry.id,
-      slug: entry.slug,
-      title: entry.title,
-      summary: entry.summary,
-      status: entry.status,
-      visibility: entry.visibility,
-      frontmatter: entry.frontmatter,
-      body: entry.body,
-      relativePath: entry.relativePath,
-      filePath: entry.filePath,
-      updatedAt: entry.updatedAt
-    };
-    const renderedPayload = {
-      format: "markdown",
-      body: entry.body
-    };
-    const searchText = markdownText(entry.body);
-    const searchPayload = {
-      model: entry.model,
-      id: entry.id,
-      slug: entry.slug,
-      title: entry.title,
-      summary: entry.summary,
-      text: searchText,
-      updatedAt: entry.updatedAt
-    };
-    const content = objectInputForJson(context.teamId, "objects", contentPayload);
-    const rendered = objectInputForJson(context.teamId, "objects", renderedPayload);
-    const search = objectInputForJson(context.teamId, "objects", searchPayload);
-    return {
-      entry: {
-        id: entry.id,
-        model: entry.model,
-        slug: entry.slug,
-        title: entry.title,
-        summary: entry.summary,
-        status: entry.status,
-        visibility: entry.visibility,
-        teamId: context.teamId,
-        publishedAt: context.generatedAt,
-        updatedAt: entry.updatedAt,
-        content: content.pointer,
-        rendered: rendered.pointer,
-        search: search.pointer,
-        metadata: {
-          relativePath: entry.relativePath,
-          ...entry.frontmatter
-        }
-      },
-      objects: [content.object, rendered.object, search.object],
-      searchText
-    };
-  }
-}
-class DefaultCollectionIndexBuilder {
-  async build(model, entries, context) {
-    const index = {
-      model,
-      generatedAt: context.generatedAt,
-      count: entries.length,
-      entries
-    };
-    const object = objectInputForJson(context.teamId, "objects", index);
-    return { index, object: object.object };
-  }
-}
-function buildDocsTree(entries) {
-  return entries.filter((entry) => entry.model === "docs").map((entry) => ({
-    id: entry.id,
-    slug: entry.slug,
-    title: entry.title,
-    summary: entry.summary,
-    path: entry.slug.startsWith("knowledge/") ? `/${entry.slug}/` : `/knowledge/${entry.slug}/`
-  }));
-}
-class DefaultRuntimeBundleBuilder {
-  async build(context, entries) {
-    const objects = [];
-    const runtime = {};
-    if (entries.some((entry) => entry.model === "books")) runtime.docsHomePath = "/books/";
-    const docsTree = buildDocsTree(entries);
-    if (docsTree.length > 0) {
-      const pointer = objectInputForJson(context.teamId, "objects", docsTree);
-      objects.push(pointer.object);
-      runtime.docsTree = pointer.pointer;
-      runtime.docsHomePath = runtime.docsHomePath ?? "/knowledge/";
-    }
-    const searchIndex = entries.map((entry) => ({
-      id: `${entry.model}:${entry.id}`,
-      model: entry.model,
-      slug: entry.slug,
-      title: entry.title,
-      summary: entry.summary,
-      search: entry.search?.objectKey ?? null,
-      updatedAt: entry.updatedAt
-    }));
-    if (searchIndex.length > 0) {
-      const pointer = objectInputForJson(context.teamId, "objects", searchIndex);
-      objects.push(pointer.object);
-      runtime.searchIndex = pointer.pointer;
-    }
-    return { runtime, objects };
-  }
-}
-function collectGeneratedArtifacts(projectRoot) {
-  const outputRoot = resolve(projectRoot, "public", "books");
-  if (!existsSync(outputRoot)) {
-    return [];
-  }
-  return readdirSync(outputRoot).map((entry) => resolve(outputRoot, entry)).filter((filePath) => statSync(filePath).isFile() && extname(filePath).toLowerCase() === ".zip").sort((left, right) => left.localeCompare(right));
-}
-export {
-  DefaultCollectionIndexBuilder,
-  DefaultEntryRenderer,
-  DefaultRuntimeBundleBuilder,
-  FilesystemContentSource,
-  buildDocsTree,
-  collectGeneratedArtifacts,
-  listMarkdownFiles
-};

package/dist/platform/published-content-pipeline/resolve-publication-access-mode.d.ts

@@ -1,119 +0,0 @@
-import { type PublicationAccessMode } from '../../entrypoints/models/sdk-types.js';
-import type { CatalogIndexEntry } from '../packages/published-content.js';
-import { type PublishContentObjectInput, type PublishedArtifactVersion, type PublishedCollectionIndex, type PublishedContentEntry, type PublishedContentManifest, type PublishedContentObjectPointer, type PublishedContentVisibility, type PublishedOverlayManifest, type PublishedRuntimePointers } from '../packages/published-content.js';
-import type { DeployConfig, TenantConfig } from '../support/contracts.js';
-/** Normalize publication access metadata without coupling content to a sales system. */
-export declare function resolvePublicationAccessMode(value: unknown): PublicationAccessMode;
-export interface ContentSourceEntry {
-    model: string;
-    id: string;
-    slug: string;
-    title?: string;
-    summary?: string;
-    status?: string;
-    visibility?: PublishedContentVisibility;
-    frontmatter: Record<string, unknown>;
-    body: string;
-    relativePath: string;
-    filePath: string;
-    updatedAt: string;
-}
-export interface ContentSource {
-    listEntries(): Promise<ContentSourceEntry[]>;
-}
-export interface RenderedContentEntry {
-    entry: PublishedContentEntry;
-    objects: PublishContentObjectInput[];
-    searchText: string;
-}
-export interface EntryRenderer {
-    render(entry: ContentSourceEntry, context: PublishedContentPipelineContext): Promise<RenderedContentEntry>;
-}
-export interface CollectionIndexBuilder {
-    build(model: string, entries: PublishedContentEntry[], context: PublishedContentPipelineContext): Promise<{
-        index: PublishedCollectionIndex;
-        object: PublishContentObjectInput;
-    }>;
-}
-export interface RuntimeBundleBuilderResult {
-    runtime: PublishedRuntimePointers;
-    objects: PublishContentObjectInput[];
-}
-export interface RuntimeBundleBuilder {
-    build(context: PublishedContentPipelineContext, entries: PublishedContentEntry[]): Promise<RuntimeBundleBuilderResult>;
-}
-export interface ArtifactBuilderResult {
-    artifacts: PublishedArtifactVersion[];
-    objects: PublishContentObjectInput[];
-    catalog?: CatalogIndexEntry[];
-}
-export interface ArtifactBuilder {
-    build(context: PublishedContentPipelineContext, entries: PublishedContentEntry[]): Promise<ArtifactBuilderResult>;
-}
-export interface PublishedContentPipelineContext {
-    projectRoot: string;
-    siteConfig: DeployConfig;
-    tenantConfig: TenantConfig;
-    teamId: string;
-    generatedAt: string;
-    sourceCommit?: string | null;
-    sourceRef?: string | null;
-    previewId?: string | null;
-}
-export interface PublishedContentPipeline {
-    buildProductionRevision(options?: {
-        previousManifest?: PublishedContentManifest | null;
-    }): Promise<{
-        manifest: PublishedContentManifest;
-        objects: PublishContentObjectInput[];
-        catalog: CatalogIndexEntry[];
-    }>;
-    buildEditorialOverlay(options?: {
-        previousManifest?: PublishedContentManifest | null;
-        previewId: string;
-    }): Promise<{
-        overlay: PublishedOverlayManifest;
-        objects: PublishContentObjectInput[];
-        catalog: CatalogIndexEntry[];
-    }>;
-}
-export declare function stableHash(value: Buffer | string): string;
-export declare function inferContentType(fileName: string): "application/json" | "application/octet-stream" | "text/markdown; charset=utf-8" | "text/mdx; charset=utf-8";
-export declare function objectPointerForBuffer(teamId: string, buffer: Buffer, kind: 'objects' | 'artifacts', extension?: string): PublishedContentObjectPointer;
-export declare function objectInputForJson(teamId: string, kind: 'objects' | 'artifacts', value: unknown): {
-    pointer: PublishedContentObjectPointer;
-    object: PublishContentObjectInput;
-};
-export declare function objectInputForFile(teamId: string, filePath: string, kind: 'objects' | 'artifacts'): {
-    pointer: {
-        contentType: string;
-        objectKey: string;
-        sha256: string;
-        size?: number;
-        publicUrl?: string;
-    };
-    object: {
-        pointer: {
-            contentType: string;
-            objectKey: string;
-            sha256: string;
-            size?: number;
-            publicUrl?: string;
-        };
-        body: NonSharedBuffer;
-        httpMetadata: {
-            contentType: string;
-        };
-    };
-};
-export declare function normalizeRelativeMarkdownPath(filePath: string, rootPath: string): string;
-export declare function normalizeSlug(model: string, relativePath: string, frontmatter: Record<string, unknown>): string;
-export declare function inferTitle(relativePath: string, frontmatter: Record<string, unknown>): string;
-export declare function inferSummary(frontmatter: Record<string, unknown>, searchText: string): string | undefined;
-export declare function inferStatus(frontmatter: Record<string, unknown>): string;
-export declare function inferVisibility(frontmatter: Record<string, unknown>): PublishedContentVisibility;
-export declare function markdownText(body: string): string;
-export declare function canonicalEntryPath(entry: Pick<PublishedContentEntry, 'model' | 'slug' | 'id'>): string;
-export declare function canonicalArtifactKey(artifact: PublishedArtifactVersion): string;
-export declare function entrySignature(entry: PublishedContentEntry): string;
-export declare function artifactSignature(artifact: PublishedArtifactVersion): string;

package/dist/platform/published-content-pipeline/resolve-publication-access-mode.js

@@ -1,143 +0,0 @@
-import { toString } from "mdast-util-to-string";
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { basename, extname, relative } from "node:path";
-import remarkParse from "remark-parse";
-import { unified } from "unified";
-import { PUBLICATION_ACCESS_MODES } from "../../entrypoints/models/sdk-types.js";
-function resolvePublicationAccessMode(value) {
-  return typeof value === "string" && PUBLICATION_ACCESS_MODES.includes(value) ? value : "free";
-}
-function stableHash(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function inferContentType(fileName) {
-  const extension = extname(fileName).toLowerCase();
-  if (extension === ".json") return "application/json";
-  if (extension === ".md") return "text/markdown; charset=utf-8";
-  if (extension === ".mdx") return "text/mdx; charset=utf-8";
-  return "application/octet-stream";
-}
-function objectPointerForBuffer(teamId, buffer, kind, extension = ".json") {
-  const sha256 = stableHash(buffer);
-  return {
-    objectKey: `teams/${teamId}/${kind}/${sha256}${extension}`,
-    sha256,
-    size: buffer.byteLength,
-    contentType: inferContentType(`entry${extension}`)
-  };
-}
-function objectInputForJson(teamId, kind, value) {
-  const buffer = Buffer.from(JSON.stringify(value, null, 2));
-  const pointer = objectPointerForBuffer(teamId, buffer, kind, ".json");
-  return {
-    pointer,
-    object: {
-      pointer: { ...pointer, contentType: "application/json" },
-      body: buffer,
-      httpMetadata: { contentType: "application/json" }
-    }
-  };
-}
-function objectInputForFile(teamId, filePath, kind) {
-  const buffer = readFileSync(filePath);
-  const extension = extname(filePath) || ".bin";
-  const pointer = objectPointerForBuffer(teamId, buffer, kind, extension);
-  return {
-    pointer: { ...pointer, contentType: inferContentType(filePath) },
-    object: {
-      pointer: { ...pointer, contentType: inferContentType(filePath) },
-      body: buffer,
-      httpMetadata: { contentType: inferContentType(filePath) }
-    }
-  };
-}
-function normalizeRelativeMarkdownPath(filePath, rootPath) {
-  return relative(rootPath, filePath).replaceAll("\\", "/");
-}
-function normalizeSlug(model, relativePath, frontmatter) {
-  const configured = typeof frontmatter.slug === "string" && frontmatter.slug.trim() ? frontmatter.slug.trim() : relativePath.replace(/\.(md|mdx)$/iu, "").replace(/\/index$/iu, "").replace(/^\/+|\/+$/gu, "");
-  if (model === "docs") {
-    if (configured === "knowledge" || configured.startsWith("knowledge/")) {
-      return configured;
-    }
-    return configured ? `knowledge/${configured}` : "knowledge";
-  }
-  return configured || basename(relativePath, extname(relativePath));
-}
-function inferTitle(relativePath, frontmatter) {
-  if (typeof frontmatter.title === "string" && frontmatter.title.trim()) {
-    return frontmatter.title.trim();
-  }
-  if (typeof frontmatter.name === "string" && frontmatter.name.trim()) {
-    return frontmatter.name.trim();
-  }
-  return basename(relativePath, extname(relativePath)).replace(/[-_]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
-}
-function inferSummary(frontmatter, searchText) {
-  for (const field of ["summary", "description", "excerpt"]) {
-    if (typeof frontmatter[field] === "string" && frontmatter[field].trim()) {
-      return frontmatter[field].trim();
-    }
-  }
-  return searchText.trim().slice(0, 240) || void 0;
-}
-function inferStatus(frontmatter) {
-  if (typeof frontmatter.status === "string" && frontmatter.status.trim()) {
-    return frontmatter.status.trim();
-  }
-  if (frontmatter.draft === true) {
-    return "draft";
-  }
-  return "live";
-}
-function inferVisibility(frontmatter) {
-  if (typeof frontmatter.visibility === "string" && frontmatter.visibility.trim()) {
-    return frontmatter.visibility.trim();
-  }
-  if (frontmatter.draft === true) {
-    return "team";
-  }
-  return "public";
-}
-function markdownText(body) {
-  try {
-    const tree = unified().use(remarkParse).parse(body);
-    return toString(tree).replace(/\s+/g, " ").trim();
-  } catch {
-    return body.replace(/`{1,3}[^`]*`{1,3}/g, " ").replace(/[#>*_~[\]()!-]+/g, " ").replace(/\s+/g, " ").trim();
-  }
-}
-function canonicalEntryPath(entry) {
-  return `${entry.model}/${entry.slug || entry.id}`.replace(/^\/+|\/+$/g, "");
-}
-function canonicalArtifactKey(artifact) {
-  return `${artifact.kind}:${artifact.itemId}:${artifact.version}`;
-}
-function entrySignature(entry) {
-  const { publishedAt, ...rest } = entry;
-  return stableHash(JSON.stringify(rest));
-}
-function artifactSignature(artifact) {
-  const { publishedAt, ...rest } = artifact;
-  return stableHash(JSON.stringify(rest));
-}
-export {
-  artifactSignature,
-  canonicalArtifactKey,
-  canonicalEntryPath,
-  entrySignature,
-  inferContentType,
-  inferStatus,
-  inferSummary,
-  inferTitle,
-  inferVisibility,
-  markdownText,
-  normalizeRelativeMarkdownPath,
-  normalizeSlug,
-  objectInputForFile,
-  objectInputForJson,
-  objectPointerForBuffer,
-  resolvePublicationAccessMode,
-  stableHash
-};

package/dist/platform/reconciliation/desired-state.d.ts

@@ -1,6 +0,0 @@
-export * from '../desired-state/compile-desired-resource-graph.js';
-export * from '../desired-state/desired-environment.js';
-export * from '../desired-state/local-development-resources.js';
-export * from '../desired-state/package-resources.js';
-export * from '../desired-state/release-gate-resources.js';
-export * from '../desired-state/safe-tree-dx-repository-name.js';

package/dist/platform/reconciliation/desired-state.js

@@ -1,6 +0,0 @@
-export * from "../desired-state/compile-desired-resource-graph.js";
-export * from "../desired-state/desired-environment.js";
-export * from "../desired-state/local-development-resources.js";
-export * from "../desired-state/package-resources.js";
-export * from "../desired-state/release-gate-resources.js";
-export * from "../desired-state/safe-tree-dx-repository-name.js";