@ctxindex/profiles 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ctxindex contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+# @ctxindex/profiles
+
+Portable, versioned domain Profiles for ctxindex Resources.
+
+```ts
+import { mailMessageProfile } from '@ctxindex/profiles/mail-message'
+
+console.log(mailMessageProfile.id)
+```
+
+The package exports the complete Profile collection from `@ctxindex/profiles`
+and dedicated `calendar-event`, `chat-message`, `mail-message`, and `file`
+subpaths. Profile schemas use the tested Zod version shared with
+`@ctxindex/extension-sdk`.
+
+Licensed under MIT.

package/dist/calendar-event.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+export declare const calendarEventSchema: z.ZodObject<{
+    provider: z.ZodString;
+    providerCalendarId: z.ZodString;
+    providerEventId: z.ZodString;
+    timing: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"timed">;
+        start: z.ZodISODateTime;
+        end: z.ZodISODateTime;
+        startTimeZone: z.ZodOptional<z.ZodString>;
+        endTimeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"all-day">;
+        startDate: z.ZodISODate;
+        endDate: z.ZodISODate;
+    }, z.core.$strict>], "kind">;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        tentative: "tentative";
+        confirmed: "confirmed";
+        cancelled: "cancelled";
+    }>;
+    organizer: z.ZodOptional<z.ZodObject<{
+        displayName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        self: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    attendees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        responseStatus: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            "needs-action": "needs-action";
+            tentative: "tentative";
+            accepted: "accepted";
+            declined: "declined";
+            organizer: "organizer";
+        }>>;
+        displayName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        self: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    recurrenceRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    series: z.ZodOptional<z.ZodObject<{
+        providerEventId: z.ZodString;
+        ref: z.ZodString;
+        originalStart: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"timed">;
+            at: z.ZodISODateTime;
+            timeZone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"all-day">;
+            date: z.ZodISODate;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+    providerUrl: z.ZodOptional<z.ZodURL>;
+    createdAt: z.ZodOptional<z.ZodISODateTime>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type CalendarEvent = z.infer<typeof calendarEventSchema>;
+export declare function calendarEventRef(sourceId: string, opaqueEventId: string): string;
+export declare const calendarEventProfile: import("@ctxindex/extension-sdk").ProfileDefinition<"calendar.event", 1, z.ZodObject<{
+    provider: z.ZodString;
+    providerCalendarId: z.ZodString;
+    providerEventId: z.ZodString;
+    timing: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"timed">;
+        start: z.ZodISODateTime;
+        end: z.ZodISODateTime;
+        startTimeZone: z.ZodOptional<z.ZodString>;
+        endTimeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"all-day">;
+        startDate: z.ZodISODate;
+        endDate: z.ZodISODate;
+    }, z.core.$strict>], "kind">;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        tentative: "tentative";
+        confirmed: "confirmed";
+        cancelled: "cancelled";
+    }>;
+    organizer: z.ZodOptional<z.ZodObject<{
+        displayName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        self: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    attendees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        responseStatus: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            "needs-action": "needs-action";
+            tentative: "tentative";
+            accepted: "accepted";
+            declined: "declined";
+            organizer: "organizer";
+        }>>;
+        displayName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        self: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    recurrenceRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    series: z.ZodOptional<z.ZodObject<{
+        providerEventId: z.ZodString;
+        ref: z.ZodString;
+        originalStart: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"timed">;
+            at: z.ZodISODateTime;
+            timeZone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"all-day">;
+            date: z.ZodISODate;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+    providerUrl: z.ZodOptional<z.ZodURL>;
+    createdAt: z.ZodOptional<z.ZodISODateTime>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>>;

package/dist/calendar-event.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  calendarEventProfile,
+  calendarEventRef,
+  calendarEventSchema
+} from "./chunks/index-x7wy2y2c.js";
+export {
+  calendarEventSchema,
+  calendarEventRef,
+  calendarEventProfile
+};

package/dist/chat-message.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const chatMessageSchema: z.ZodObject<{
+    providerMessageId: z.ZodString;
+    conversationKey: z.ZodString;
+    sender: z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    sentAt: z.ZodISODateTime;
+    editedAt: z.ZodOptional<z.ZodISODateTime>;
+    text: z.ZodOptional<z.ZodString>;
+    replyTo: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        providerMessageId: z.ZodString;
+        conversationKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        byteSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    unread: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ChatMessage = z.infer<typeof chatMessageSchema>;
+export declare function chatMessageNaturalKey(conversationKey: string, providerMessageId: string): string;
+export declare const chatMessageProfile: import("@ctxindex/extension-sdk").ProfileDefinition<"chat.message", 1, z.ZodObject<{
+    providerMessageId: z.ZodString;
+    conversationKey: z.ZodString;
+    sender: z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    sentAt: z.ZodISODateTime;
+    editedAt: z.ZodOptional<z.ZodISODateTime>;
+    text: z.ZodOptional<z.ZodString>;
+    replyTo: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        providerMessageId: z.ZodString;
+        conversationKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        byteSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    unread: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>>;

package/dist/chat-message.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  chatMessageNaturalKey,
+  chatMessageProfile,
+  chatMessageSchema
+} from "./chunks/index-e0nk6n94.js";
+export {
+  chatMessageSchema,
+  chatMessageProfile,
+  chatMessageNaturalKey
+};

package/dist/chunks/index-3sp1af8a.js

@@ -0,0 +1,178 @@
+// @bun
+// packages/profiles/src/mail-message.ts
+import { defineProfile } from "@ctxindex/extension-sdk";
+import { z } from "zod";
+var artifactDescriptorSchema = z.object({
+  ref: z.string().min(1),
+  filename: z.string().optional(),
+  mediaType: z.string().optional(),
+  byteSize: z.number().int().nonnegative().optional()
+}).strict();
+var headerValueSchema = z.string().min(1).regex(/^[^\r\n]*$/);
+var mailMessageDraftStandaloneContentShape = {
+  to: z.array(headerValueSchema).min(1),
+  cc: z.array(headerValueSchema).optional(),
+  bcc: z.array(headerValueSchema).optional(),
+  subject: z.string().regex(/^[^\r\n]*$/),
+  bodyText: z.string()
+};
+var mailMessageDraftAttachmentSchema = z.object({ ref: z.string().min(1) }).strict();
+var MAX_DRAFT_ATTACHMENT_COUNT = 10;
+var MAX_DRAFT_ATTACHMENT_BYTES = 2 * 1024 * 1024;
+var draftAttachmentsSchema = z.array(mailMessageDraftAttachmentSchema).min(1).max(MAX_DRAFT_ATTACHMENT_COUNT).superRefine((attachments, context) => {
+  const seen = new Set;
+  for (const [index, attachment] of attachments.entries()) {
+    if (seen.has(attachment.ref))
+      context.addIssue({
+        code: "custom",
+        message: "Draft attachment Refs must be unique",
+        path: [index, "ref"]
+      });
+    seen.add(attachment.ref);
+  }
+});
+var mailMessageDraftReplyContentShape = {
+  replyToRef: z.string().min(1),
+  bodyText: z.string()
+};
+var mailMessageDraftStandaloneCreateInputSchema = z.object({
+  ...mailMessageDraftStandaloneContentShape,
+  attachments: draftAttachmentsSchema.optional()
+}).strict();
+var mailMessageDraftReplyCreateInputSchema = z.object({
+  ...mailMessageDraftReplyContentShape,
+  attachments: draftAttachmentsSchema.optional()
+}).strict();
+var mailMessageDraftCreateInputSchema = z.union([
+  mailMessageDraftStandaloneCreateInputSchema,
+  mailMessageDraftReplyCreateInputSchema
+]);
+var mailMessageDraftStandaloneUpdateInputSchema = z.object({
+  ref: z.string().min(1),
+  ...mailMessageDraftStandaloneContentShape
+}).strict();
+var mailMessageDraftReplyUpdateInputSchema = z.object({
+  ref: z.string().min(1),
+  ...mailMessageDraftReplyContentShape
+}).strict();
+var mailMessageDraftUpdateInputSchema = z.union([
+  mailMessageDraftStandaloneUpdateInputSchema,
+  mailMessageDraftReplyUpdateInputSchema
+]);
+function sanitizeHeader(value) {
+  return value.replace(/[\r\n]+/g, " ");
+}
+function renderEml(payload) {
+  const headers = [];
+  const addHeader = (name, value) => {
+    if (value !== undefined)
+      headers.push(`${name}: ${sanitizeHeader(value)}`);
+  };
+  addHeader("From", payload.from?.map(sanitizeHeader).join(", "));
+  addHeader("To", payload.to?.map(sanitizeHeader).join(", "));
+  addHeader("Cc", payload.cc?.map(sanitizeHeader).join(", "));
+  addHeader("Bcc", payload.bcc?.map(sanitizeHeader).join(", "));
+  addHeader("Subject", payload.subject);
+  addHeader("Date", payload.date === undefined ? undefined : new Date(payload.date).toUTCString());
+  addHeader("Message-ID", payload.rfcMessageId);
+  addHeader("In-Reply-To", payload.inReplyTo);
+  headers.push("MIME-Version: 1.0", "Content-Type: text/plain; charset=utf-8", "Content-Transfer-Encoding: 8bit");
+  const body = (payload.bodyText ?? "").replace(/\r\n|\r|\n/g, `\r
+`);
+  return `${headers.join(`\r
+`)}\r
+\r
+${body}`;
+}
+var mailMessageSchema = z.object({
+  providerMessageId: z.string().min(1),
+  providerDraftId: z.string().min(1).optional(),
+  threadId: z.string().min(1).optional(),
+  conversationKey: z.string().min(1).optional(),
+  rfcMessageId: z.string().min(1).optional(),
+  inReplyTo: z.string().min(1).optional(),
+  references: z.array(z.string().min(1)).optional(),
+  replyTo: z.array(z.string().min(1)).optional(),
+  replyToRef: z.string().min(1).optional(),
+  subject: z.string().optional(),
+  from: z.array(z.string()).optional(),
+  to: z.array(z.string()).optional(),
+  cc: z.array(z.string()).optional(),
+  bcc: z.array(z.string()).optional(),
+  date: z.string().datetime().optional(),
+  snippet: z.string().optional(),
+  bodyText: z.string().optional(),
+  labels: z.array(z.string()).optional(),
+  unread: z.boolean().optional(),
+  attachments: z.array(artifactDescriptorSchema).optional(),
+  managedAttachmentRefs: z.array(z.string().min(1)).optional()
+}).strict();
+function deriveMailMessageReplyRecipient(payload) {
+  return payload.replyTo?.[0] ?? payload.from?.[0];
+}
+function deriveMailMessageReplySubject(subject) {
+  const base = (subject ?? "").replace(/^(?:\s*re\s*:\s*)+/i, "").trim();
+  return base ? `Re: ${base}` : "Re:";
+}
+function deriveMailMessageReplyReferences(references, rfcMessageId) {
+  return [...new Set([...references ?? [], rfcMessageId])];
+}
+var mailMessageProfile = defineProfile({
+  id: "mail.message",
+  version: 1,
+  schema: mailMessageSchema,
+  actions: {
+    "mail.message.draft.create": {
+      effect: "reversible",
+      input: mailMessageDraftCreateInputSchema,
+      output: { id: "mail.message", version: 1 }
+    },
+    "mail.message.draft.update": {
+      effect: "reversible",
+      input: mailMessageDraftUpdateInputSchema,
+      output: { id: "mail.message", version: 1 }
+    }
+  },
+  search: {
+    title: (payload) => payload.subject ?? null,
+    occurredAt: (payload) => payload.date === undefined ? null : new Date(payload.date),
+    chunks: (payload) => [
+      ...payload.subject === undefined ? [] : [payload.subject],
+      ...payload.from ?? [],
+      ...payload.to ?? [],
+      ...payload.snippet === undefined ? [] : [payload.snippet],
+      ...payload.bodyText === undefined ? [] : [payload.bodyText]
+    ],
+    fields: {
+      sender: {
+        type: "string[]",
+        extract: (payload) => payload.from ?? []
+      },
+      unread: {
+        type: "boolean",
+        extract: (payload) => payload.unread
+      },
+      rfcMessageId: {
+        type: "string",
+        extract: (payload) => payload.rfcMessageId
+      },
+      conversationKey: {
+        type: "string",
+        extract: (payload) => payload.conversationKey
+      }
+    }
+  },
+  artifacts: (payload) => [...payload.attachments ?? []],
+  relations: {
+    conversation: (payload) => payload.conversationKey ? { field: "conversationKey", value: payload.conversationKey } : undefined,
+    parent: (payload) => payload.inReplyTo ? { field: "rfcMessageId", value: payload.inReplyTo } : undefined
+  },
+  exports: {
+    eml: {
+      mediaType: "message/rfc822",
+      render: renderEml
+    }
+  }
+});
+
+export { mailMessageDraftAttachmentSchema, MAX_DRAFT_ATTACHMENT_COUNT, MAX_DRAFT_ATTACHMENT_BYTES, mailMessageDraftCreateInputSchema, mailMessageDraftUpdateInputSchema, mailMessageSchema, deriveMailMessageReplyRecipient, deriveMailMessageReplySubject, deriveMailMessageReplyReferences, mailMessageProfile };

package/dist/chunks/index-e0nk6n94.js

@@ -0,0 +1,132 @@
+// @bun
+// packages/profiles/src/chat-message.ts
+import { defineProfile } from "@ctxindex/extension-sdk";
+import { z } from "zod";
+var instantSchema = z.iso.datetime({ offset: true });
+var conversationKeySchema = z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}:chat:.+$/);
+var resourceRefSchema = z.string().regex(/^ctx:\/\/[0-9A-HJKMNP-TV-Z]{26}\/(?:[A-Za-z0-9\-._~!$&'()*+,;=:@/]|%[0-9A-F]{2})+$/).refine((ref) => {
+  const suffix = ref.slice(ref.indexOf("/", "ctx://".length) + 1);
+  return new TextEncoder().encode(suffix).length <= 16 * 1024;
+}, "ctxindex Ref suffix exceeds 16 KiB");
+var chatParticipantSchema = z.object({
+  id: z.string().min(1),
+  displayName: z.string().min(1).optional()
+}).strict();
+var chatAttachmentSchema = z.object({
+  ref: z.string().min(1),
+  filename: z.string().min(1).optional(),
+  mediaType: z.string().min(1).optional(),
+  byteSize: z.number().int().nonnegative().optional()
+}).strict();
+var chatReplyTargetSchema = z.union([
+  z.object({ ref: resourceRefSchema }).strict(),
+  z.object({
+    providerMessageId: z.string().min(1),
+    conversationKey: conversationKeySchema.optional()
+  }).strict()
+]);
+var chatMessageSchema = z.object({
+  providerMessageId: z.string().min(1),
+  conversationKey: conversationKeySchema,
+  sender: chatParticipantSchema,
+  sentAt: instantSchema,
+  editedAt: instantSchema.optional(),
+  text: z.string().min(1).optional(),
+  replyTo: chatReplyTargetSchema.optional(),
+  attachments: z.array(chatAttachmentSchema).min(1).optional(),
+  unread: z.boolean().optional()
+}).strict().superRefine((message, context) => {
+  if (message.text === undefined && message.attachments === undefined) {
+    context.addIssue({
+      code: "custom",
+      message: "A chat message requires text or at least one attachment"
+    });
+  }
+  if (message.editedAt !== undefined && Date.parse(message.editedAt) < Date.parse(message.sentAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "Chat message edit time must not precede sent time",
+      path: ["editedAt"]
+    });
+  }
+});
+function chatMessageNaturalKey(conversationKey, providerMessageId) {
+  return JSON.stringify([conversationKey, providerMessageId]);
+}
+function takeCodePoints(value, limit) {
+  return Array.from(value).slice(0, limit).join("");
+}
+function chatMessageTitle(message) {
+  const text = message.text?.replace(/\s+/g, " ").trim();
+  return takeCodePoints(text || message.attachments?.[0]?.filename || message.sender.displayName || message.sender.id, 120);
+}
+function chatMessageChunks(message) {
+  return [
+    message.text,
+    message.sender.displayName,
+    message.sender.id,
+    ...(message.attachments ?? []).flatMap((attachment) => [
+      attachment.filename,
+      attachment.mediaType
+    ])
+  ].filter((value) => value !== undefined);
+}
+var chatMessageProfile = defineProfile({
+  id: "chat.message",
+  version: 1,
+  schema: chatMessageSchema,
+  search: {
+    title: chatMessageTitle,
+    occurredAt: (message) => new Date(message.sentAt),
+    chunks: chatMessageChunks,
+    fields: {
+      providerMessageId: {
+        type: "string",
+        extract: (message) => message.providerMessageId
+      },
+      messageKey: {
+        type: "string",
+        extract: (message) => chatMessageNaturalKey(message.conversationKey, message.providerMessageId)
+      },
+      conversationKey: {
+        type: "string",
+        extract: (message) => message.conversationKey
+      },
+      senderId: {
+        type: "string",
+        extract: (message) => message.sender.id
+      },
+      sentAt: {
+        type: "datetime",
+        extract: (message) => new Date(message.sentAt)
+      },
+      editedAt: {
+        type: "datetime",
+        extract: (message) => message.editedAt === undefined ? undefined : new Date(message.editedAt)
+      },
+      unread: {
+        type: "boolean",
+        extract: (message) => message.unread
+      }
+    }
+  },
+  relations: {
+    conversation: (message) => ({
+      field: "conversationKey",
+      value: message.conversationKey
+    }),
+    parent: (message) => {
+      if (message.replyTo === undefined)
+        return;
+      if ("ref" in message.replyTo)
+        return { ref: message.replyTo.ref };
+      return {
+        field: "messageKey",
+        value: chatMessageNaturalKey(message.replyTo.conversationKey ?? message.conversationKey, message.replyTo.providerMessageId)
+      };
+    }
+  },
+  artifacts: (message) => [...message.attachments ?? []]
+});
+
+export { chatMessageSchema, chatMessageNaturalKey, chatMessageProfile };

package/dist/chunks/index-m7k8kdqj.js

@@ -0,0 +1,95 @@
+// @bun
+// packages/profiles/src/file.ts
+import { defineProfile } from "@ctxindex/extension-sdk";
+import { z } from "zod";
+var CHUNK_TARGET = 1500;
+var CHUNK_OVERLAP = 200;
+var CHUNK_MAX = 3000;
+function chunkText(text) {
+  if (!text.trim())
+    return [];
+  const chunks = [];
+  let offset = 0;
+  let index = 0;
+  while (offset < text.length) {
+    let end = Math.min(offset + CHUNK_TARGET, text.length);
+    if (end < text.length) {
+      const window = text.slice(offset, Math.min(offset + CHUNK_MAX, text.length));
+      const paragraphIndex = window.lastIndexOf(`
+
+`);
+      if (paragraphIndex > CHUNK_TARGET / 2) {
+        end = offset + paragraphIndex + 2;
+      } else {
+        const headingIndex = window.lastIndexOf(`
+#`);
+        if (headingIndex > CHUNK_TARGET / 2) {
+          end = offset + headingIndex + 1;
+        } else {
+          const newlineIndex = window.lastIndexOf(`
+`);
+          if (newlineIndex > CHUNK_TARGET / 2) {
+            end = offset + newlineIndex + 1;
+          }
+        }
+      }
+    }
+    const content = text.slice(offset, end).trim();
+    if (content)
+      chunks.push({ index: index++, content });
+    if (end >= text.length)
+      break;
+    offset = Math.max(offset + 1, end - CHUNK_OVERLAP);
+  }
+  return chunks;
+}
+function isNormalizedRelativeFilePath(path) {
+  if (path.length === 0 || path.startsWith("/") || /^[A-Za-z]:[/]/.test(path) || path.includes("\\")) {
+    return false;
+  }
+  const segments = path.split("/");
+  return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function extensionOf(name) {
+  const dot = name.lastIndexOf(".");
+  return dot > 0 && dot < name.length - 1 ? name.slice(dot + 1) : undefined;
+}
+var fileSchema = z.object({
+  path: z.string().refine(isNormalizedRelativeFilePath),
+  name: z.string().min(1),
+  mediaType: z.string().min(1),
+  byteSize: z.number().int().nonnegative(),
+  modifiedAt: z.string().datetime(),
+  contentHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+  text: z.string()
+}).strict();
+var fileProfile = defineProfile({
+  id: "file",
+  version: 1,
+  schema: fileSchema,
+  search: {
+    title: (payload) => payload.path,
+    occurredAt: (payload) => new Date(payload.modifiedAt),
+    chunks: (payload) => chunkText(payload.text).map(({ content }) => content),
+    fields: {
+      path: { type: "string", extract: (payload) => payload.path },
+      name: { type: "string", extract: (payload) => payload.name },
+      extension: {
+        type: "string",
+        extract: (payload) => extensionOf(payload.name)
+      },
+      mediaType: { type: "string", extract: (payload) => payload.mediaType },
+      size: { type: "number", extract: (payload) => payload.byteSize },
+      modifiedAt: {
+        type: "datetime",
+        extract: (payload) => new Date(payload.modifiedAt)
+      },
+      contentHash: {
+        type: "string",
+        extract: (payload) => payload.contentHash
+      }
+    }
+  }
+});
+
+export { chunkText, isNormalizedRelativeFilePath, fileSchema, fileProfile };

package/dist/chunks/index-x7wy2y2c.js

@@ -0,0 +1,191 @@
+// @bun
+// packages/profiles/src/calendar-event.ts
+import { defineProfile } from "@ctxindex/extension-sdk";
+import { z } from "zod";
+var sourceIdPattern = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+var providerIdPattern = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/;
+var instantSchema = z.iso.datetime({ offset: true });
+var dateSchema = z.iso.date();
+var participantShape = {
+  displayName: z.string().min(1).optional(),
+  email: z.string().min(1).optional(),
+  self: z.boolean().optional()
+};
+var participantSchema = z.object(participantShape).strict().refine((participant) => participant.displayName !== undefined || participant.email !== undefined, "A participant requires a display name or email");
+var attendeeSchema = z.object({
+  ...participantShape,
+  responseStatus: z.enum([
+    "none",
+    "needs-action",
+    "tentative",
+    "accepted",
+    "declined",
+    "organizer"
+  ]).optional()
+}).strict().refine((participant) => participant.displayName !== undefined || participant.email !== undefined, "An attendee requires a display name or email");
+var timedTimingSchema = z.object({
+  kind: z.literal("timed"),
+  start: instantSchema,
+  end: instantSchema,
+  startTimeZone: z.string().min(1).optional(),
+  endTimeZone: z.string().min(1).optional()
+}).strict().refine((timing) => Date.parse(timing.end) > Date.parse(timing.start), "Timed event end must be after start");
+var allDayTimingSchema = z.object({
+  kind: z.literal("all-day"),
+  startDate: dateSchema,
+  endDate: dateSchema
+}).strict().refine((timing) => timing.endDate > timing.startDate, "All-day event end date must be after start date");
+var occurrenceStartSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("timed"),
+    at: instantSchema,
+    timeZone: z.string().min(1).optional()
+  }).strict(),
+  z.object({ kind: z.literal("all-day"), date: dateSchema }).strict()
+]);
+function isCanonicalEventRef(value) {
+  const match = /^ctx:\/\/([^/]+)\/event\/([^/?#]+)$/.exec(value);
+  if (!match?.[1] || !match[2] || !sourceIdPattern.test(match[1]))
+    return false;
+  try {
+    return encodeURIComponent(decodeURIComponent(match[2])) === match[2];
+  } catch {
+    return false;
+  }
+}
+var seriesSchema = z.object({
+  providerEventId: z.string().min(1),
+  ref: z.string().refine(isCanonicalEventRef, "Invalid calendar series Ref"),
+  originalStart: occurrenceStartSchema
+}).strict();
+var httpsUrlSchema = z.url().refine((value) => {
+  const url = new URL(value);
+  return url.protocol === "https:" && url.username === "" && url.password === "";
+}, "Provider URL must be credential-free HTTPS");
+var calendarEventSchema = z.object({
+  provider: z.string().regex(providerIdPattern),
+  providerCalendarId: z.string().min(1),
+  providerEventId: z.string().min(1),
+  timing: z.discriminatedUnion("kind", [
+    timedTimingSchema,
+    allDayTimingSchema
+  ]),
+  title: z.string().min(1).optional(),
+  description: z.string().min(1).optional(),
+  location: z.string().min(1).optional(),
+  status: z.enum(["confirmed", "tentative", "cancelled"]),
+  organizer: participantSchema.optional(),
+  attendees: z.array(attendeeSchema).optional(),
+  recurrenceRules: z.array(z.string().min(1)).min(1).optional(),
+  series: seriesSchema.optional(),
+  providerUrl: httpsUrlSchema.optional(),
+  createdAt: instantSchema.optional(),
+  updatedAt: instantSchema.optional()
+}).strict().refine((event) => event.createdAt === undefined || event.updatedAt === undefined || Date.parse(event.updatedAt) >= Date.parse(event.createdAt), "Calendar Event update time must not precede creation time");
+function takeCodePoints(value, limit) {
+  return Array.from(value).slice(0, limit).join("");
+}
+function participantText(participant) {
+  if (participant.displayName && participant.email) {
+    return `${participant.displayName} <${participant.email}>`;
+  }
+  return participant.email ?? participant.displayName;
+}
+function participantIdentity(participant) {
+  return participant.email ?? participant.displayName;
+}
+function calendarEventSummary(event) {
+  const summary = event.description ?? event.location;
+  return summary === undefined ? null : takeCodePoints(summary, 500);
+}
+function calendarEventChunks(event) {
+  const people = [
+    ...event.organizer === undefined ? [] : [participantText(event.organizer)],
+    ...(event.attendees ?? []).map(participantText)
+  ].join(`
+`);
+  return [event.title, event.description, event.location, people].filter((value) => value !== undefined && value.length > 0).map((value) => takeCodePoints(value, 3000));
+}
+function calendarEventRef(sourceId, opaqueEventId) {
+  if (!sourceIdPattern.test(sourceId)) {
+    throw new TypeError("Calendar Event Ref requires an uppercase Source ULID");
+  }
+  if (opaqueEventId.length === 0) {
+    throw new TypeError("Calendar Event Ref requires a provider event id");
+  }
+  return `ctx://${sourceId}/event/${encodeURIComponent(opaqueEventId)}`;
+}
+var calendarEventProfile = defineProfile({
+  id: "calendar.event",
+  version: 1,
+  schema: calendarEventSchema,
+  search: {
+    title: (event) => event.title ?? null,
+    summary: calendarEventSummary,
+    occurredAt: (event) => event.timing.kind === "timed" ? new Date(event.timing.start) : null,
+    chunks: calendarEventChunks,
+    fields: {
+      provider: {
+        type: "string",
+        extract: (event) => event.provider
+      },
+      calendarId: {
+        type: "string",
+        extract: (event) => event.providerCalendarId
+      },
+      eventId: {
+        type: "string",
+        extract: (event) => event.providerEventId
+      },
+      title: {
+        type: "string",
+        extract: (event) => event.title
+      },
+      status: {
+        type: "string",
+        extract: (event) => event.status
+      },
+      allDay: {
+        type: "boolean",
+        extract: (event) => event.timing.kind === "all-day"
+      },
+      startsAt: {
+        type: "datetime",
+        extract: (event) => event.timing.kind === "timed" ? new Date(event.timing.start) : undefined
+      },
+      endsAt: {
+        type: "datetime",
+        extract: (event) => event.timing.kind === "timed" ? new Date(event.timing.end) : undefined
+      },
+      startDate: {
+        type: "string",
+        extract: (event) => event.timing.kind === "all-day" ? event.timing.startDate : undefined
+      },
+      endDate: {
+        type: "string",
+        extract: (event) => event.timing.kind === "all-day" ? event.timing.endDate : undefined
+      },
+      organizer: {
+        type: "string",
+        extract: (event) => event.organizer === undefined ? undefined : participantIdentity(event.organizer)
+      },
+      attendees: {
+        type: "string[]",
+        extract: (event) => (event.attendees ?? []).map(participantIdentity)
+      },
+      seriesEventId: {
+        type: "string",
+        extract: (event) => event.series?.providerEventId
+      },
+      updatedAt: {
+        type: "datetime",
+        extract: (event) => event.updatedAt === undefined ? undefined : new Date(event.updatedAt)
+      }
+    }
+  },
+  relations: {
+    series: (event) => event.series === undefined ? undefined : { ref: event.series.ref }
+  }
+});
+
+export { calendarEventSchema, calendarEventRef, calendarEventProfile };

package/dist/file.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export interface FileChunk {
+    index: number;
+    content: string;
+}
+export declare function chunkText(text: string): FileChunk[];
+export declare function isNormalizedRelativeFilePath(path: string): boolean;
+export declare const fileSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodString;
+    mediaType: z.ZodString;
+    byteSize: z.ZodNumber;
+    modifiedAt: z.ZodString;
+    contentHash: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+export declare const fileProfile: import("@ctxindex/extension-sdk").ProfileDefinition<"file", 1, z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodString;
+    mediaType: z.ZodString;
+    byteSize: z.ZodNumber;
+    modifiedAt: z.ZodString;
+    contentHash: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>>;

package/dist/file.js

@@ -0,0 +1,13 @@
+// @bun
+import {
+  chunkText,
+  fileProfile,
+  fileSchema,
+  isNormalizedRelativeFilePath
+} from "./chunks/index-m7k8kdqj.js";
+export {
+  isNormalizedRelativeFilePath,
+  fileSchema,
+  fileProfile,
+  chunkText
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { CalendarEvent } from './calendar-event.js';
+export { calendarEventProfile, calendarEventRef, calendarEventSchema, } from './calendar-event.js';
+export type { ChatMessage } from './chat-message.js';
+export { chatMessageNaturalKey, chatMessageProfile, chatMessageSchema, } from './chat-message.js';
+export type { FileChunk } from './file.js';
+export { chunkText, fileProfile, fileSchema, isNormalizedRelativeFilePath, } from './file.js';
+export type { MailMessage } from './mail-message.js';
+export { deriveMailMessageReplyRecipient, deriveMailMessageReplyReferences, deriveMailMessageReplySubject, MAX_DRAFT_ATTACHMENT_BYTES, MAX_DRAFT_ATTACHMENT_COUNT, mailMessageDraftAttachmentSchema, mailMessageDraftCreateInputSchema, mailMessageDraftUpdateInputSchema, mailMessageProfile, mailMessageSchema, } from './mail-message.js';

package/dist/index.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  calendarEventProfile,
+  calendarEventRef,
+  calendarEventSchema
+} from "./chunks/index-x7wy2y2c.js";
+import {
+  chatMessageNaturalKey,
+  chatMessageProfile,
+  chatMessageSchema
+} from "./chunks/index-e0nk6n94.js";
+import {
+  MAX_DRAFT_ATTACHMENT_BYTES,
+  MAX_DRAFT_ATTACHMENT_COUNT,
+  deriveMailMessageReplyRecipient,
+  deriveMailMessageReplyReferences,
+  deriveMailMessageReplySubject,
+  mailMessageDraftAttachmentSchema,
+  mailMessageDraftCreateInputSchema,
+  mailMessageDraftUpdateInputSchema,
+  mailMessageProfile,
+  mailMessageSchema
+} from "./chunks/index-3sp1af8a.js";
+import {
+  chunkText,
+  fileProfile,
+  fileSchema,
+  isNormalizedRelativeFilePath
+} from "./chunks/index-m7k8kdqj.js";
+export {
+  mailMessageSchema,
+  mailMessageProfile,
+  mailMessageDraftUpdateInputSchema,
+  mailMessageDraftCreateInputSchema,
+  mailMessageDraftAttachmentSchema,
+  isNormalizedRelativeFilePath,
+  fileSchema,
+  fileProfile,
+  deriveMailMessageReplySubject,
+  deriveMailMessageReplyReferences,
+  deriveMailMessageReplyRecipient,
+  chunkText,
+  chatMessageSchema,
+  chatMessageProfile,
+  chatMessageNaturalKey,
+  calendarEventSchema,
+  calendarEventRef,
+  calendarEventProfile,
+  MAX_DRAFT_ATTACHMENT_COUNT,
+  MAX_DRAFT_ATTACHMENT_BYTES
+};

package/dist/mail-message.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export declare const mailMessageDraftAttachmentSchema: z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strict>;
+export declare const MAX_DRAFT_ATTACHMENT_COUNT = 10;
+export declare const MAX_DRAFT_ATTACHMENT_BYTES: number;
+export declare const mailMessageDraftCreateInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>>>;
+    to: z.ZodArray<z.ZodString>;
+    cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subject: z.ZodString;
+    bodyText: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>>>;
+    replyToRef: z.ZodString;
+    bodyText: z.ZodString;
+}, z.core.$strict>]>;
+export declare const mailMessageDraftUpdateInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    to: z.ZodArray<z.ZodString>;
+    cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    subject: z.ZodString;
+    bodyText: z.ZodString;
+    ref: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    replyToRef: z.ZodString;
+    bodyText: z.ZodString;
+    ref: z.ZodString;
+}, z.core.$strict>]>;
+export declare const mailMessageSchema: z.ZodObject<{
+    providerMessageId: z.ZodString;
+    providerDraftId: z.ZodOptional<z.ZodString>;
+    threadId: z.ZodOptional<z.ZodString>;
+    conversationKey: z.ZodOptional<z.ZodString>;
+    rfcMessageId: z.ZodOptional<z.ZodString>;
+    inReplyTo: z.ZodOptional<z.ZodString>;
+    references: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    replyTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    replyToRef: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    to: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    date: z.ZodOptional<z.ZodString>;
+    snippet: z.ZodOptional<z.ZodString>;
+    bodyText: z.ZodOptional<z.ZodString>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    unread: z.ZodOptional<z.ZodBoolean>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        byteSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    managedAttachmentRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type MailMessage = z.infer<typeof mailMessageSchema>;
+export declare function deriveMailMessageReplyRecipient(payload: MailMessage): string | undefined;
+export declare function deriveMailMessageReplySubject(subject: string | undefined): string;
+export declare function deriveMailMessageReplyReferences(references: readonly string[] | undefined, rfcMessageId: string): string[];
+export declare const mailMessageProfile: import("@ctxindex/extension-sdk").ProfileDefinition<"mail.message", 1, z.ZodObject<{
+    providerMessageId: z.ZodString;
+    providerDraftId: z.ZodOptional<z.ZodString>;
+    threadId: z.ZodOptional<z.ZodString>;
+    conversationKey: z.ZodOptional<z.ZodString>;
+    rfcMessageId: z.ZodOptional<z.ZodString>;
+    inReplyTo: z.ZodOptional<z.ZodString>;
+    references: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    replyTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    replyToRef: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    to: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    date: z.ZodOptional<z.ZodString>;
+    snippet: z.ZodOptional<z.ZodString>;
+    bodyText: z.ZodOptional<z.ZodString>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    unread: z.ZodOptional<z.ZodBoolean>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        byteSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    managedAttachmentRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>;

package/dist/mail-message.js

@@ -0,0 +1,25 @@
+// @bun
+import {
+  MAX_DRAFT_ATTACHMENT_BYTES,
+  MAX_DRAFT_ATTACHMENT_COUNT,
+  deriveMailMessageReplyRecipient,
+  deriveMailMessageReplyReferences,
+  deriveMailMessageReplySubject,
+  mailMessageDraftAttachmentSchema,
+  mailMessageDraftCreateInputSchema,
+  mailMessageDraftUpdateInputSchema,
+  mailMessageProfile,
+  mailMessageSchema
+} from "./chunks/index-3sp1af8a.js";
+export {
+  mailMessageSchema,
+  mailMessageProfile,
+  mailMessageDraftUpdateInputSchema,
+  mailMessageDraftCreateInputSchema,
+  mailMessageDraftAttachmentSchema,
+  deriveMailMessageReplySubject,
+  deriveMailMessageReplyReferences,
+  deriveMailMessageReplyRecipient,
+  MAX_DRAFT_ATTACHMENT_COUNT,
+  MAX_DRAFT_ATTACHMENT_BYTES
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@ctxindex/profiles",
+  "version": "0.1.0",
+  "description": "Portable domain Profiles for ctxindex Resources.",
+  "license": "MIT",
+  "homepage": "https://ctxindex.com",
+  "bugs": {
+    "url": "https://github.com/barisgit/ctxindex/issues"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./calendar-event": {
+      "types": "./dist/calendar-event.d.ts",
+      "import": "./dist/calendar-event.js"
+    },
+    "./chat-message": {
+      "types": "./dist/chat-message.d.ts",
+      "import": "./dist/chat-message.js"
+    },
+    "./mail-message": {
+      "types": "./dist/mail-message.d.ts",
+      "import": "./dist/mail-message.js"
+    },
+    "./file": {
+      "types": "./dist/file.d.ts",
+      "import": "./dist/file.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": "1.3.14"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/barisgit/ctxindex.git",
+    "directory": "packages/profiles"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@ctxindex/extension-sdk": "0.1.0",
+    "zod": "^4.4.3"
+  }
+}