@treeseed/core 0.1.2

package/dist/utils/agents/contracts/messages.d.ts

@@ -0,0 +1,88 @@
+export interface QuestionPriorityUpdatedMessage {
+    questionId: string;
+    reason: string;
+    plannerRunId: string;
+}
+export interface ObjectivePriorityUpdatedMessage {
+    objectiveId: string;
+    reason: string;
+    plannerRunId: string;
+}
+export interface ArchitectureUpdatedMessage {
+    objectiveId: string;
+    knowledgeId: string;
+    architectRunId: string;
+}
+export interface SubscriberNotifiedMessage {
+    email: string;
+    itemCount: number;
+    notifierRunId: string;
+}
+export interface ResearchStartedMessage {
+    questionId: string;
+    researcherRunId: string;
+}
+export interface ResearchCompletedMessage {
+    questionId: string;
+    knowledgeId: string | null;
+    researcherRunId: string;
+}
+export interface TaskCompleteMessage {
+    branchName: string | null;
+    changedTargets: string[];
+    engineerRunId: string;
+}
+export interface TaskWaitingMessage {
+    blockingReason: string;
+    engineerRunId: string;
+}
+export interface TaskFailedMessage {
+    failureSummary: string;
+    engineerRunId: string;
+}
+export interface TaskVerifiedMessage {
+    branchName: string | null;
+    reviewerRunId: string;
+}
+export interface ReviewFailedMessage {
+    failureSummary: string;
+    reviewerRunId: string;
+}
+export interface ReviewWaitingMessage {
+    blockingReason: string;
+    reviewerRunId: string;
+}
+export interface ReleaseStartedMessage {
+    taskRunId: string | null;
+    releaserRunId: string;
+}
+export interface ReleaseCompletedMessage {
+    releaseSummary: string;
+    releaserRunId: string;
+}
+export interface ReleaseFailedMessage {
+    failureSummary: string;
+    releaserRunId: string;
+}
+export interface AgentMessageContracts {
+    question_priority_updated: QuestionPriorityUpdatedMessage;
+    objective_priority_updated: ObjectivePriorityUpdatedMessage;
+    architecture_updated: ArchitectureUpdatedMessage;
+    subscriber_notified: SubscriberNotifiedMessage;
+    research_started: ResearchStartedMessage;
+    research_completed: ResearchCompletedMessage;
+    task_complete: TaskCompleteMessage;
+    task_waiting: TaskWaitingMessage;
+    task_failed: TaskFailedMessage;
+    task_verified: TaskVerifiedMessage;
+    review_failed: ReviewFailedMessage;
+    review_waiting: ReviewWaitingMessage;
+    release_started: ReleaseStartedMessage;
+    release_completed: ReleaseCompletedMessage;
+    release_failed: ReleaseFailedMessage;
+}
+export type AgentMessageType = keyof AgentMessageContracts;
+export type AgentMessagePayload<TType extends AgentMessageType> = AgentMessageContracts[TType];
+export declare const AGENT_MESSAGE_TYPES: readonly ["question_priority_updated", "objective_priority_updated", "architecture_updated", "subscriber_notified", "research_started", "research_completed", "task_complete", "task_waiting", "task_failed", "task_verified", "review_failed", "review_waiting", "release_started", "release_completed", "release_failed"];
+export declare function parseAgentMessagePayload<TType extends AgentMessageType>(type: TType, payloadJson: string): AgentMessagePayload<TType>;
+export declare function serializeAgentMessagePayload<TType extends AgentMessageType>(type: TType, payload: AgentMessagePayload<TType>): Record<string, unknown>;

package/dist/utils/agents/contracts/messages.js

@@ -0,0 +1,138 @@
+const AGENT_MESSAGE_TYPES = [
+  "question_priority_updated",
+  "objective_priority_updated",
+  "architecture_updated",
+  "subscriber_notified",
+  "research_started",
+  "research_completed",
+  "task_complete",
+  "task_waiting",
+  "task_failed",
+  "task_verified",
+  "review_failed",
+  "review_waiting",
+  "release_started",
+  "release_completed",
+  "release_failed"
+];
+function ensureString(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Invalid ${label}: expected non-empty string.`);
+  }
+  return value;
+}
+function ensureOptionalString(value, label) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return ensureString(value, label);
+}
+function ensureStringArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid ${label}: expected array.`);
+  }
+  return value.map((entry, index) => ensureString(entry, `${label}[${index}]`));
+}
+function ensureNumber(value, label) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new Error(`Invalid ${label}: expected number.`);
+  }
+  return value;
+}
+function parseAgentMessagePayload(type, payloadJson) {
+  const parsed = JSON.parse(payloadJson);
+  switch (type) {
+    case "question_priority_updated":
+      return {
+        questionId: ensureString(parsed.questionId, "questionId"),
+        reason: ensureString(parsed.reason, "reason"),
+        plannerRunId: ensureString(parsed.plannerRunId, "plannerRunId")
+      };
+    case "objective_priority_updated":
+      return {
+        objectiveId: ensureString(parsed.objectiveId, "objectiveId"),
+        reason: ensureString(parsed.reason, "reason"),
+        plannerRunId: ensureString(parsed.plannerRunId, "plannerRunId")
+      };
+    case "architecture_updated":
+      return {
+        objectiveId: ensureString(parsed.objectiveId, "objectiveId"),
+        knowledgeId: ensureString(parsed.knowledgeId, "knowledgeId"),
+        architectRunId: ensureString(parsed.architectRunId, "architectRunId")
+      };
+    case "subscriber_notified":
+      return {
+        email: ensureString(parsed.email, "email"),
+        itemCount: ensureNumber(parsed.itemCount, "itemCount"),
+        notifierRunId: ensureString(parsed.notifierRunId, "notifierRunId")
+      };
+    case "research_started":
+      return {
+        questionId: ensureString(parsed.questionId, "questionId"),
+        researcherRunId: ensureString(parsed.researcherRunId, "researcherRunId")
+      };
+    case "research_completed":
+      return {
+        questionId: ensureString(parsed.questionId, "questionId"),
+        knowledgeId: ensureOptionalString(parsed.knowledgeId, "knowledgeId"),
+        researcherRunId: ensureString(parsed.researcherRunId, "researcherRunId")
+      };
+    case "task_complete":
+      return {
+        branchName: ensureOptionalString(parsed.branchName, "branchName"),
+        changedTargets: ensureStringArray(parsed.changedTargets, "changedTargets"),
+        engineerRunId: ensureString(parsed.engineerRunId, "engineerRunId")
+      };
+    case "task_waiting":
+      return {
+        blockingReason: ensureString(parsed.blockingReason, "blockingReason"),
+        engineerRunId: ensureString(parsed.engineerRunId, "engineerRunId")
+      };
+    case "task_failed":
+      return {
+        failureSummary: ensureString(parsed.failureSummary, "failureSummary"),
+        engineerRunId: ensureString(parsed.engineerRunId, "engineerRunId")
+      };
+    case "task_verified":
+      return {
+        branchName: ensureOptionalString(parsed.branchName, "branchName"),
+        reviewerRunId: ensureString(parsed.reviewerRunId, "reviewerRunId")
+      };
+    case "review_failed":
+      return {
+        failureSummary: ensureString(parsed.failureSummary, "failureSummary"),
+        reviewerRunId: ensureString(parsed.reviewerRunId, "reviewerRunId")
+      };
+    case "review_waiting":
+      return {
+        blockingReason: ensureString(parsed.blockingReason, "blockingReason"),
+        reviewerRunId: ensureString(parsed.reviewerRunId, "reviewerRunId")
+      };
+    case "release_started":
+      return {
+        taskRunId: ensureOptionalString(parsed.taskRunId, "taskRunId"),
+        releaserRunId: ensureString(parsed.releaserRunId, "releaserRunId")
+      };
+    case "release_completed":
+      return {
+        releaseSummary: ensureString(parsed.releaseSummary, "releaseSummary"),
+        releaserRunId: ensureString(parsed.releaserRunId, "releaserRunId")
+      };
+    case "release_failed":
+      return {
+        failureSummary: ensureString(parsed.failureSummary, "failureSummary"),
+        releaserRunId: ensureString(parsed.releaserRunId, "releaserRunId")
+      };
+    default:
+      throw new Error(`Unsupported message type "${type}".`);
+  }
+}
+function serializeAgentMessagePayload(type, payload) {
+  parseAgentMessagePayload(type, JSON.stringify(payload));
+  return payload;
+}
+export {
+  AGENT_MESSAGE_TYPES,
+  parseAgentMessagePayload,
+  serializeAgentMessagePayload
+};

package/dist/utils/agents/contracts/run.d.ts

@@ -0,0 +1,20 @@
+export type AgentErrorCategory = 'trigger_resolution_error' | 'permission_error' | 'message_claim_error' | 'lease_error' | 'execution_error' | 'mutation_error' | 'sdk_error';
+export interface AgentRunTrace {
+    [key: string]: unknown;
+    runId: string;
+    agentSlug: string;
+    handlerKind: string;
+    triggerKind: string;
+    triggerSource: string;
+    claimedMessageId: number | null;
+    selectedItemKey: string | null;
+    branchName: string | null;
+    commitSha: string | null;
+    changedPaths: string[];
+    summary: string | null;
+    error: string | null;
+    errorCategory: AgentErrorCategory | null;
+    startedAt: string;
+    finishedAt: string | null;
+    status: string;
+}

package/dist/utils/agents/runtime-types.d.ts

@@ -0,0 +1,117 @@
+import type { AgentHandlerKind, AgentRuntimeSpec, AgentRunStatus, AgentTriggerConfig } from '@treeseed/sdk/types/agents';
+import type { AgentErrorCategory } from './contracts/run.ts';
+import type { ScopedAgentSdk, SdkMessageEntity } from '@treeseed/sdk';
+export interface AgentTriggerInvocation {
+    kind: 'startup' | 'schedule' | 'message' | 'manual' | 'follow';
+    source: string;
+    trigger: AgentTriggerConfig;
+    message?: SdkMessageEntity | null;
+    followModels?: string[];
+    cursorValue?: string | null;
+}
+export interface AgentExecutionResult {
+    status: AgentRunStatus;
+    summary: string;
+    stdout?: string;
+    stderr?: string;
+    errorCategory?: AgentErrorCategory | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentMutationResult {
+    branchName: string | null;
+    commitMessage: string | null;
+    worktreePath: string | null;
+    commitSha: string | null;
+    changedPaths: string[];
+}
+export interface AgentRepositoryInspectionResult {
+    branchName: string | null;
+    changedPaths: string[];
+    commitSha: string | null;
+    summary: string;
+}
+export interface AgentVerificationResult {
+    status: 'completed' | 'failed' | 'waiting';
+    summary: string;
+    stdout?: string;
+    stderr?: string;
+    errorCategory?: AgentErrorCategory | null;
+}
+export interface AgentNotificationResult {
+    status: 'completed' | 'failed' | 'waiting';
+    summary: string;
+    deliveredCount: number;
+}
+export interface AgentResearchResult {
+    status: 'completed' | 'failed' | 'waiting';
+    summary: string;
+    markdown: string;
+    sources?: string[];
+    errorCategory?: AgentErrorCategory | null;
+}
+export interface AgentExecutionAdapter {
+    runTask(input: {
+        agent: AgentRuntimeSpec;
+        runId: string;
+        prompt: string;
+    }): Promise<AgentExecutionResult>;
+}
+export interface AgentMutationAdapter {
+    writeArtifact(input: {
+        runId: string;
+        agent: AgentRuntimeSpec;
+        relativePath: string;
+        content: string;
+        commitMessage: string;
+    }): Promise<AgentMutationResult>;
+}
+export interface AgentRepositoryInspectionAdapter {
+    inspectBranch(input: {
+        repoRoot: string;
+        branchName: string | null;
+    }): Promise<AgentRepositoryInspectionResult>;
+}
+export interface AgentVerificationAdapter {
+    runChecks(input: {
+        agent: AgentRuntimeSpec;
+        runId: string;
+        commands: string[];
+    }): Promise<AgentVerificationResult>;
+}
+export interface AgentNotificationAdapter {
+    deliver(input: {
+        agent: AgentRuntimeSpec;
+        runId: string;
+        recipients: string[];
+        subject: string;
+        body: string;
+    }): Promise<AgentNotificationResult>;
+}
+export interface AgentResearchAdapter {
+    research(input: {
+        agent: AgentRuntimeSpec;
+        runId: string;
+        questionId: string;
+        reason: string | null;
+    }): Promise<AgentResearchResult>;
+}
+export interface AgentContext {
+    runId: string;
+    repoRoot: string;
+    agent: AgentRuntimeSpec;
+    sdk: ScopedAgentSdk;
+    trigger: AgentTriggerInvocation;
+    execution: AgentExecutionAdapter;
+    mutations: AgentMutationAdapter;
+    repository: AgentRepositoryInspectionAdapter;
+    verification: AgentVerificationAdapter;
+    notifications: AgentNotificationAdapter;
+    research: AgentResearchAdapter;
+}
+export interface AgentHandler<TInputs = unknown, TResult = unknown> {
+    kind: AgentHandlerKind;
+    resolveInputs(context: AgentContext): Promise<TInputs>;
+    execute(context: AgentContext, inputs: TInputs): Promise<TResult>;
+    emitOutputs(context: AgentContext, result: TResult): Promise<AgentExecutionResult>;
+}
+export declare const TRESEED_AGENT_RUNTIME_TYPES_MODULE = true;

package/dist/utils/agents/runtime-types.js

@@ -0,0 +1,4 @@
+const TRESEED_AGENT_RUNTIME_TYPES_MODULE = true;
+export {
+  TRESEED_AGENT_RUNTIME_TYPES_MODULE
+};

package/dist/utils/books-data.js

@@ -0,0 +1,82 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { getTenantContentRoot } from "../tenant/config.js";
+import { RUNTIME_PROJECT_ROOT, RUNTIME_TENANT } from "../tenant/runtime-config.js";
+function sortPaths(paths) {
+  return [...paths].sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
+}
+function collectMarkdownFiles(rootPath) {
+  const stats = statSync(rootPath);
+  if (stats.isFile()) {
+    return [rootPath];
+  }
+  return sortPaths(
+    readdirSync(rootPath, { withFileTypes: true }).flatMap((entry) => {
+      const fullPath = path.join(rootPath, entry.name);
+      if (entry.isDirectory()) {
+        return collectMarkdownFiles(fullPath);
+      }
+      if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
+        return [fullPath];
+      }
+      return [];
+    })
+  );
+}
+function parseFrontmatter(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) {
+    throw new Error(`Book content entry is missing frontmatter: ${filePath}`);
+  }
+  return parseYaml(match[1]);
+}
+function inferDocsLibraryDownload(book) {
+  const title = book?.title ? `${book.title} Library` : "Knowledge Library";
+  return {
+    downloadFileName: "treeseed-knowledge.md",
+    downloadHref: "/books/treeseed-knowledge.md",
+    downloadTitle: title
+  };
+}
+function buildTenantBookRuntime(tenantConfig, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const booksContentRoot = path.resolve(projectRoot, getTenantContentRoot(tenantConfig, "books"));
+  const books = collectMarkdownFiles(booksContentRoot).map((filePath) => {
+    const frontmatter = parseFrontmatter(filePath);
+    return {
+      ...frontmatter,
+      id: path.basename(filePath, path.extname(filePath))
+    };
+  }).sort((left, right) => left.order - right.order);
+  const docsHomePath = options.docsHomePath ?? "/knowledge/";
+  const docsLibraryDownload = options.docsLibraryDownload ?? inferDocsLibraryDownload(tenantConfig);
+  return {
+    BOOKS: books,
+    BOOKS_LINK: {
+      label: "Books",
+      link: docsHomePath
+    },
+    TREESEED_LINKS: {
+      home: docsHomePath
+    },
+    TREESEED_LIBRARY_DOWNLOAD: docsLibraryDownload
+  };
+}
+const runtime = buildTenantBookRuntime(RUNTIME_TENANT, {
+  projectRoot: RUNTIME_PROJECT_ROOT,
+  docsLibraryDownload: {
+    downloadFileName: "treeseed-knowledge.md",
+    downloadHref: "/books/treeseed-knowledge.md",
+    downloadTitle: "TreeSeed Knowledge Library"
+  }
+});
+const { BOOKS, BOOKS_LINK, TREESEED_LINKS, TREESEED_LIBRARY_DOWNLOAD } = runtime;
+export {
+  BOOKS,
+  BOOKS_LINK,
+  TREESEED_LIBRARY_DOWNLOAD,
+  TREESEED_LINKS,
+  buildTenantBookRuntime
+};

package/dist/utils/content-status.js

@@ -0,0 +1,38 @@
+import { SITE } from "./site-config.js";
+const CONTENT_STATUSES = ["live", "in progress", "exploratory", "planned", "speculative"];
+const CONTENT_STATUS_META = {
+  live: {
+    label: "Live",
+    description: "Materially exists and is maintained.",
+    tone: "border-[color:var(--site-accent)]/35 bg-[color:var(--site-accent-soft)] text-[color:var(--site-accent-strong)]"
+  },
+  "in progress": {
+    label: "In Progress",
+    description: "Actively being built or hardened.",
+    tone: "border-[color:var(--site-warm)]/40 bg-[color:rgba(215,176,123,0.18)] text-[color:var(--site-warm-strong)]"
+  },
+  exploratory: {
+    label: "Exploratory",
+    description: "Directionally important, but still unsettled.",
+    tone: "border-[color:var(--site-blue)]/40 bg-[color:var(--site-blue-soft)] text-[color:var(--site-blue-strong)]"
+  },
+  planned: {
+    label: "Planned",
+    description: "Intended, but not started in a meaningful way.",
+    tone: "border-[color:#9c9277]/35 bg-[color:rgba(156,146,119,0.14)] text-[color:#5f5743]"
+  },
+  speculative: {
+    label: "Speculative",
+    description: "Conceptual or long-range, not a current commitment.",
+    tone: "border-[color:#a39b8e]/35 bg-[color:rgba(163,155,142,0.14)] text-[color:#4d4638]"
+  }
+};
+const PROJECT_STAGE = {
+  label: SITE.projectStage,
+  description: SITE.projectStageDetail
+};
+export {
+  CONTENT_STATUSES,
+  CONTENT_STATUS_META,
+  PROJECT_STAGE
+};

package/dist/utils/forms/config.js

@@ -0,0 +1,87 @@
+import {
+  TREESEED_FORM_TOKEN_SECRET,
+  TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS,
+  TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE,
+  TREESEED_FORMS_LOCAL_USE_MAILPIT,
+  TREESEED_LOCAL_DEV_MODE,
+  TREESEED_MAILPIT_SMTP_HOST,
+  TREESEED_MAILPIT_SMTP_PORT,
+  TREESEED_SMTP_FROM,
+  TREESEED_SMTP_HOST,
+  TREESEED_SMTP_PASSWORD,
+  TREESEED_SMTP_PORT,
+  TREESEED_SMTP_REPLY_TO,
+  TREESEED_SMTP_USERNAME,
+  TREESEED_TURNSTILE_SECRET_KEY
+} from "astro:env/server";
+import { SITE_EMAIL_NOTIFICATIONS } from "../site-config.js";
+import { getTreeseedFormsProvider, isTreeseedSmtpEnabled, isTreeseedTurnstileEnabled } from "../../deploy/runtime.js";
+function getFormSecret() {
+  return TREESEED_FORM_TOKEN_SECRET ?? "";
+}
+function getTurnstileSecret() {
+  return TREESEED_TURNSTILE_SECRET_KEY ?? "";
+}
+function getContactRoutingMap() {
+  return SITE_EMAIL_NOTIFICATIONS.contactRouting;
+}
+function getSubscribeRecipients() {
+  return SITE_EMAIL_NOTIFICATIONS.subscribeRecipients;
+}
+function getSmtpConfig() {
+  const useMailpit = TREESEED_FORMS_LOCAL_USE_MAILPIT ?? false;
+  return {
+    host: useMailpit ? TREESEED_MAILPIT_SMTP_HOST ?? TREESEED_SMTP_HOST ?? "127.0.0.1" : TREESEED_SMTP_HOST ?? "",
+    port: useMailpit ? TREESEED_MAILPIT_SMTP_PORT ?? TREESEED_SMTP_PORT ?? 1025 : TREESEED_SMTP_PORT ?? 465,
+    username: TREESEED_SMTP_USERNAME ?? "",
+    password: TREESEED_SMTP_PASSWORD ?? "",
+    from: TREESEED_SMTP_FROM ?? "",
+    replyTo: TREESEED_SMTP_REPLY_TO ?? ""
+  };
+}
+function getFormsMode() {
+  return getTreeseedFormsProvider();
+}
+function getLocalDevMode() {
+  if (TREESEED_LOCAL_DEV_MODE === "cloudflare") {
+    return "cloudflare";
+  }
+  return null;
+}
+function shouldBypassTurnstileByEnv() {
+  return TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE;
+}
+function shouldBypassCloudflareGuardsByEnv() {
+  return TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS;
+}
+function shouldUseMailpit() {
+  return TREESEED_FORMS_LOCAL_USE_MAILPIT ?? false;
+}
+function isSmtpConfigured() {
+  const smtp = getSmtpConfig();
+  return Boolean(smtp.host && smtp.port && smtp.from);
+}
+function isSmtpEnabled() {
+  if (shouldUseMailpit()) {
+    return true;
+  }
+  return isTreeseedSmtpEnabled() && isSmtpConfigured();
+}
+function isTurnstileEnabled() {
+  return isTreeseedTurnstileEnabled() && Boolean(getTurnstileSecret());
+}
+export {
+  getContactRoutingMap,
+  getFormSecret,
+  getFormsMode,
+  getLocalDevMode,
+  getSmtpConfig,
+  getSubscribeRecipients,
+  getTurnstileSecret,
+  isSmtpConfigured,
+  isSmtpEnabled,
+  isTurnstileEnabled,
+  shouldBypassCloudflareGuardsByEnv,
+  shouldBypassTurnstileByEnv,
+  shouldUseMailpit
+};

package/dist/utils/forms/constants.js

@@ -0,0 +1,27 @@
+const FORM_SESSION_COOKIE = "treeseed_form_session";
+const FORM_TOKEN_TTL_MS = 30 * 60 * 1e3;
+const NONCE_TTL_SECONDS = 60 * 60;
+const RATE_LIMIT_TTL_SECONDS = 10 * 60;
+const RATE_LIMIT_MAX_ATTEMPTS = 3;
+const HONEYPOT_FIELD = "website";
+const FORM_SUCCESS_PARAM = "formStatus";
+const FORM_CODE_PARAM = "formCode";
+const SUBSCRIBE_ANCHOR_ID = "site-subscribe";
+const CONTACT_TYPE_LABELS = {
+  question: "Question",
+  feedback: "Feedback",
+  collaboration: "Collaboration",
+  issue: "Report Issue"
+};
+export {
+  CONTACT_TYPE_LABELS,
+  FORM_CODE_PARAM,
+  FORM_SESSION_COOKIE,
+  FORM_SUCCESS_PARAM,
+  FORM_TOKEN_TTL_MS,
+  HONEYPOT_FIELD,
+  NONCE_TTL_SECONDS,
+  RATE_LIMIT_MAX_ATTEMPTS,
+  RATE_LIMIT_TTL_SECONDS,
+  SUBSCRIBE_ANCHOR_ID
+};

package/dist/utils/forms/contact-submissions-local.js

@@ -0,0 +1,19 @@
+import { hashValue } from "./crypto.js";
+const localContactSubmissions = globalThis.__treeseedFixtureContactSubmissions ?? [];
+globalThis.__treeseedFixtureContactSubmissions = localContactSubmissions;
+async function createLocalContactSubmission(input) {
+  localContactSubmissions.push({
+    name: input.name,
+    email: input.email,
+    organization: input.organization,
+    contactType: input.contactType,
+    subject: input.subject,
+    message: input.message,
+    userAgent: input.userAgent || "unknown user agent",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ipHash: await hashValue(input.ip || "unknown")
+  });
+}
+export {
+  createLocalContactSubmission
+};