@atproto-ui/core 0.13.0

package/dist/tangled-fetch.d.ts

@@ -0,0 +1,9 @@
+import type { RepoLanguagesResponse } from "./types/tangled";
+export interface FetchRepoLanguagesOptions {
+    knot: string;
+    did: string;
+    repoName: string;
+    branch?: string;
+    fetch?: typeof fetch;
+}
+export declare function fetchRepoLanguages({ knot, did, repoName, branch, fetch: fetchImpl, }: FetchRepoLanguagesOptions): Promise<RepoLanguagesResponse>;

package/dist/tangled-fetch.js

@@ -0,0 +1,15 @@
+import { normalizeAtIdentifier } from "./identity.js";
+async function fetchRepoLanguages({ knot: t, did: n, repoName: r, branch: i, fetch: a = fetch }) {
+	let o = i ? [i] : ["main", "master"];
+	for (let i of o) {
+		let o = normalizeAtIdentifier(t);
+		if (!o) break;
+		let s = `${(o.match(/^[a-zA-Z][a-zA-Z\d+\-.]*:/) ? o : `https://${o}`).replace(/\/+$/, "")}/xrpc/sh.tangled.repo.languages?repo=${encodeURIComponent(`${n}/${r}`)}&ref=${encodeURIComponent(i)}`;
+		try {
+			let e = await a(s);
+			if (e.ok) return await e.json();
+		} catch {}
+	}
+	throw Error(i ? `Failed to fetch languages for branch: ${i}` : "Failed to fetch languages for main or master branch");
+}
+export { fetchRepoLanguages };

package/dist/types/blob.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Extended blob reference that includes a CDN URL from appview responses.
+ * Used when fetching from Bluesky appview to avoid extra blob fetches.
+ */
+export interface BlobWithCdn {
+    $type: "blob";
+    ref: {
+        $link: string;
+    };
+    mimeType: string;
+    size: number;
+    /** CDN URL from Bluesky appview (e.g., https://cdn.bsky.app/img/avatar/plain/did:plc:xxx/bafkreixxx@jpeg) */
+    cdnUrl?: string;
+}

package/dist/types/bluesky.d.ts

@@ -0,0 +1,4 @@
+import type { AppBskyFeedPost, AppBskyActorProfile } from "@atcute/bluesky";
+export type { AppBskyFeedPost, AppBskyActorProfile };
+export type FeedPostRecord = AppBskyFeedPost.Main;
+export type ProfileRecord = AppBskyActorProfile.Main;

package/dist/types/grain.d.ts

@@ -0,0 +1,31 @@
+import type { Blob } from "@atcute/lexicons/interfaces";
+import type { BlobWithCdn } from "./blob";
+export interface GrainGalleryRecord {
+    $type: "social.grain.gallery";
+    title: string;
+    description?: string;
+    labels?: {
+        $type: "com.atproto.label.defs#selfLabels";
+        values: Array<{
+            val: string;
+        }>;
+    };
+    createdAt: string;
+}
+export interface GrainGalleryItemRecord {
+    $type: "social.grain.gallery.item";
+    item: string;
+    gallery: string;
+    position?: number;
+    createdAt: string;
+}
+export interface GrainPhotoRecord {
+    $type: "social.grain.photo";
+    alt: string;
+    photo: Blob<`image/${string}`> | BlobWithCdn;
+    createdAt?: string;
+    aspectRatio?: {
+        width: number;
+        height: number;
+    };
+}

package/dist/types/leaflet.d.ts

@@ -0,0 +1,173 @@
+export interface StrongRef {
+    uri: string;
+    cid: string;
+}
+export interface LeafletDocumentRecord {
+    $type?: "pub.leaflet.document";
+    title: string;
+    postRef?: StrongRef;
+    description?: string;
+    publishedAt?: string;
+    publication: string;
+    author: string;
+    pages: LeafletDocumentPage[];
+}
+export type LeafletDocumentPage = LeafletLinearDocumentPage;
+export interface LeafletLinearDocumentPage {
+    $type?: "pub.leaflet.pages.linearDocument";
+    blocks?: LeafletLinearDocumentBlock[];
+}
+export type LeafletAlignmentValue = "#textAlignLeft" | "#textAlignCenter" | "#textAlignRight" | "#textAlignJustify" | "textAlignLeft" | "textAlignCenter" | "textAlignRight" | "textAlignJustify";
+export interface LeafletLinearDocumentBlock {
+    block: LeafletBlock;
+    alignment?: LeafletAlignmentValue;
+}
+export type LeafletBlock = LeafletTextBlock | LeafletHeaderBlock | LeafletBlockquoteBlock | LeafletImageBlock | LeafletUnorderedListBlock | LeafletWebsiteBlock | LeafletIFrameBlock | LeafletMathBlock | LeafletCodeBlock | LeafletHorizontalRuleBlock | LeafletBskyPostBlock;
+export interface LeafletBaseTextBlock {
+    plaintext: string;
+    facets?: LeafletRichTextFacet[];
+}
+export interface LeafletTextBlock extends LeafletBaseTextBlock {
+    $type?: "pub.leaflet.blocks.text";
+}
+export interface LeafletHeaderBlock extends LeafletBaseTextBlock {
+    $type?: "pub.leaflet.blocks.header";
+    level?: number;
+}
+export interface LeafletBlockquoteBlock extends LeafletBaseTextBlock {
+    $type?: "pub.leaflet.blocks.blockquote";
+}
+export interface LeafletImageBlock {
+    $type?: "pub.leaflet.blocks.image";
+    image: LeafletBlobRef;
+    alt?: string;
+    aspectRatio: {
+        width: number;
+        height: number;
+    };
+}
+export interface LeafletUnorderedListBlock {
+    $type?: "pub.leaflet.blocks.unorderedList";
+    children: LeafletListItem[];
+}
+export interface LeafletListItem {
+    content: LeafletListContent;
+    children?: LeafletListItem[];
+}
+export type LeafletListContent = LeafletTextBlock | LeafletHeaderBlock | LeafletImageBlock;
+export interface LeafletWebsiteBlock {
+    $type?: "pub.leaflet.blocks.website";
+    src: string;
+    title?: string;
+    description?: string;
+    previewImage?: LeafletBlobRef;
+}
+export interface LeafletIFrameBlock {
+    $type?: "pub.leaflet.blocks.iframe";
+    url: string;
+    height?: number;
+}
+export interface LeafletMathBlock {
+    $type?: "pub.leaflet.blocks.math";
+    tex: string;
+}
+export interface LeafletCodeBlock {
+    $type?: "pub.leaflet.blocks.code";
+    plaintext: string;
+    language?: string;
+    syntaxHighlightingTheme?: string;
+}
+export interface LeafletHorizontalRuleBlock {
+    $type?: "pub.leaflet.blocks.horizontalRule";
+}
+export interface LeafletBskyPostBlock {
+    $type?: "pub.leaflet.blocks.bskyPost";
+    postRef: StrongRef;
+}
+export interface LeafletRichTextFacet {
+    index: LeafletByteSlice;
+    features: LeafletRichTextFeature[];
+}
+export interface LeafletByteSlice {
+    byteStart: number;
+    byteEnd: number;
+}
+export type LeafletRichTextFeature = LeafletRichTextLinkFeature | LeafletRichTextCodeFeature | LeafletRichTextHighlightFeature | LeafletRichTextUnderlineFeature | LeafletRichTextStrikethroughFeature | LeafletRichTextIdFeature | LeafletRichTextBoldFeature | LeafletRichTextItalicFeature;
+export interface LeafletRichTextLinkFeature {
+    $type: "pub.leaflet.richtext.facet#link";
+    uri: string;
+}
+export interface LeafletRichTextCodeFeature {
+    $type: "pub.leaflet.richtext.facet#code";
+}
+export interface LeafletRichTextHighlightFeature {
+    $type: "pub.leaflet.richtext.facet#highlight";
+}
+export interface LeafletRichTextUnderlineFeature {
+    $type: "pub.leaflet.richtext.facet#underline";
+}
+export interface LeafletRichTextStrikethroughFeature {
+    $type: "pub.leaflet.richtext.facet#strikethrough";
+}
+export interface LeafletRichTextIdFeature {
+    $type: "pub.leaflet.richtext.facet#id";
+    id?: string;
+}
+export interface LeafletRichTextBoldFeature {
+    $type: "pub.leaflet.richtext.facet#bold";
+}
+export interface LeafletRichTextItalicFeature {
+    $type: "pub.leaflet.richtext.facet#italic";
+}
+export interface LeafletBlobRef {
+    $type?: string;
+    ref?: {
+        $link?: string;
+    };
+    cid?: string;
+    mimeType?: string;
+    size?: number;
+}
+export interface LeafletPublicationRecord {
+    $type?: "pub.leaflet.publication";
+    name: string;
+    base_path?: string;
+    description?: string;
+    icon?: LeafletBlobRef;
+    theme?: LeafletTheme;
+    preferences?: LeafletPublicationPreferences;
+}
+export interface LeafletPublicationPreferences {
+    showInDiscover?: boolean;
+    showComments?: boolean;
+}
+export interface LeafletTheme {
+    backgroundColor?: LeafletThemeColor;
+    backgroundImage?: LeafletThemeBackgroundImage;
+    primary?: LeafletThemeColor;
+    pageBackground?: LeafletThemeColor;
+    showPageBackground?: boolean;
+    accentBackground?: LeafletThemeColor;
+    accentText?: LeafletThemeColor;
+}
+export type LeafletThemeColor = LeafletThemeColorRgb | LeafletThemeColorRgba;
+export interface LeafletThemeColorRgb {
+    $type?: "pub.leaflet.theme.color#rgb";
+    r: number;
+    g: number;
+    b: number;
+}
+export interface LeafletThemeColorRgba {
+    $type?: "pub.leaflet.theme.color#rgba";
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface LeafletThemeBackgroundImage {
+    $type?: "pub.leaflet.theme.backgroundImage";
+    image: LeafletBlobRef;
+    width?: number;
+    repeat?: boolean;
+}
+export type LeafletInlineRenderable = LeafletTextBlock | LeafletHeaderBlock | LeafletBlockquoteBlock;

package/dist/types/record.d.ts

@@ -0,0 +1,28 @@
+import type { BaseSchema, InferInput } from "@atcute/lexicons/validations";
+export type RecordTypeName<T> = T extends {
+    $type?: infer TypeName extends string;
+} ? TypeName : never;
+export type KnownRecordCollection = "app.bsky.actor.profile" | "app.bsky.feed.post" | "fm.teal.alpha.actor.status" | "fm.teal.alpha.feed.play" | "pub.leaflet.document" | "pub.leaflet.publication" | "sh.tangled.repo" | "sh.tangled.string" | "social.grain.gallery" | "social.grain.gallery.item" | "social.grain.photo";
+export type InferableRecordCollection<T> = Extract<RecordTypeName<T>, KnownRecordCollection>;
+export type InferableLatestRecordCollection<T> = InferableRecordCollection<T>;
+export interface AtcuteRecordRuntimeShape {
+    mainSchema?: {
+        object?: {
+            shape?: {
+                $type?: {
+                    expected?: unknown;
+                };
+            };
+        };
+    };
+}
+export type AtcuteRecordNamespace<TSchema extends BaseSchema = BaseSchema> = AtcuteRecordRuntimeShape & {
+    mainSchema: TSchema;
+};
+export type AtcuteRecordMain<TNamespace> = TNamespace extends {
+    mainSchema: infer Schema extends BaseSchema;
+} ? InferInput<Schema> : never;
+export type RecordCollectionInput = string | AtcuteRecordNamespace;
+export declare const DEFAULT_RECORD_COLLECTION = "app.bsky.feed.post";
+export declare const DEFAULT_LATEST_RECORD_COLLECTION = "app.bsky.feed.post";
+export declare function resolveRecordCollection(collection: RecordCollectionInput | undefined, fallback?: string): string | undefined;

package/dist/types/record.js

@@ -0,0 +1,7 @@
+const DEFAULT_RECORD_COLLECTION = "app.bsky.feed.post", DEFAULT_LATEST_RECORD_COLLECTION = DEFAULT_RECORD_COLLECTION;
+function resolveRecordCollection(e, t) {
+	if (typeof e == "string") return e;
+	let n = e?.mainSchema?.object?.shape?.$type?.expected;
+	return typeof n == "string" ? n : t;
+}
+export { DEFAULT_LATEST_RECORD_COLLECTION, DEFAULT_RECORD_COLLECTION, resolveRecordCollection };

package/dist/types/tangled.d.ts

@@ -0,0 +1,19 @@
+import type { ShTangledRepo, ShTangledString } from "@atcute/tangled";
+export type TangledRepoRecord = ShTangledRepo.Main;
+export type TangledStringRecord = ShTangledString.Main;
+/** Language information from sh.tangled.repo.languages endpoint */
+export interface RepoLanguage {
+    name: string;
+    percentage: number;
+    size: number;
+}
+/**
+ * Response from sh.tangled.repo.languages endpoint from tangled knot
+ */
+export interface RepoLanguagesResponse {
+    languages: RepoLanguage[];
+    /** Branch name */
+    ref: string;
+    totalFiles: number;
+    totalSize: number;
+}

package/dist/types/teal.d.ts

@@ -0,0 +1,36 @@
+/**
+ * teal.fm record types for music listening history
+ * Specification: fm.teal.alpha.actor.status and fm.teal.alpha.feed.play
+ */
+export interface TealArtist {
+    artistName: string;
+    artistMbId?: string;
+}
+export interface TealPlayItem {
+    artists: TealArtist[];
+    originUrl?: string;
+    trackName: string;
+    playedTime: string;
+    releaseName?: string;
+    recordingMbId?: string;
+    releaseMbId?: string;
+    submissionClientAgent?: string;
+    musicServiceBaseDomain?: string;
+    isrc?: string;
+    duration?: number;
+}
+/**
+ * fm.teal.alpha.actor.status - The last played song
+ */
+export interface TealActorStatusRecord {
+    $type: "fm.teal.alpha.actor.status";
+    item: TealPlayItem;
+    time: string;
+    expiry?: string;
+}
+/**
+ * fm.teal.alpha.feed.play - A single play record
+ */
+export interface TealFeedPlayRecord extends TealPlayItem {
+    $type: "fm.teal.alpha.feed.play";
+}

package/dist/utils/at-uri.d.ts

@@ -0,0 +1,10 @@
+export interface ParsedAtUri {
+    did: string;
+    collection: string;
+    rkey: string;
+}
+export declare function parseAtUri(uri?: string): ParsedAtUri | undefined;
+export declare function toBlueskyPostUrl(target: ParsedAtUri): string | undefined;
+export declare function formatDidForLabel(did: string): string;
+export declare function normalizeLeafletBasePath(basePath?: string): string | undefined;
+export declare function leafletRkeyUrl(basePath: string | undefined, rkey: string): string | undefined;

package/dist/utils/at-uri.js

@@ -0,0 +1,33 @@
+function parseAtUri(e) {
+	if (!e || !e.startsWith("at://")) return;
+	let [r, i, a] = e.slice(5).split("/");
+	if (!(!r || !i || !a)) return {
+		did: r,
+		collection: i,
+		rkey: a
+	};
+}
+function toBlueskyPostUrl(e) {
+	if (e.collection === "app.bsky.feed.post") return `https://bsky.app/profile/${e.did}/post/${e.rkey}`;
+}
+function formatDidForLabel(e) {
+	return e.replace(/^did:(plc:)?/, "");
+}
+var ABSOLUTE_URL_PATTERN = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+function normalizeLeafletBasePath(e) {
+	if (!e) return;
+	let r = e.trim();
+	if (!r) return;
+	let i = ABSOLUTE_URL_PATTERN.test(r) ? r : `https://${r}`;
+	try {
+		let e = new URL(i);
+		return e.hash = "", e.href.replace(/\/?$/, "");
+	} catch {
+		return;
+	}
+}
+function leafletRkeyUrl(e, r) {
+	let i = normalizeLeafletBasePath(e);
+	if (i) return `${i}/${encodeURIComponent(r)}`;
+}
+export { formatDidForLabel, leafletRkeyUrl, normalizeLeafletBasePath, parseAtUri, toBlueskyPostUrl };

package/dist/utils/blob.d.ts

@@ -0,0 +1,5 @@
+import type { BlobWithCdn } from "../types/blob";
+export declare function isBlobWithCdn(value: unknown): value is BlobWithCdn;
+export declare function getBlobImageUrl(value: unknown): string | undefined;
+export declare function extractCidFromBlob(blob: unknown): string | undefined;
+export declare function extractCidFromCdnUrl(url: string | undefined): string | undefined;

package/dist/utils/blob.js

@@ -0,0 +1,26 @@
+var CID_PATTERN = /(?:^|\/)(bafk[a-z0-9]+|bafyb[a-z0-9]+|Qm[1-9A-HJ-NP-Za-km-z]+)(?:@[^/?#]+)?(?:[/?#]|$)/i;
+function isBlobWithCdn(e) {
+	if (typeof e != "object" || !e) return !1;
+	let r = e;
+	return r.$type === "blob" && typeof r.cdnUrl == "string" && typeof r.ref == "object" && r.ref !== null && typeof r.ref.$link == "string";
+}
+function getBlobImageUrl(e) {
+	if (isBlobWithCdn(e)) return e.cdnUrl;
+	if (typeof e != "object" || !e) return;
+	let i = e;
+	if (i.$type === "blob") return typeof i.cdnUrl == "string" ? i.cdnUrl : void 0;
+}
+function extractCidFromBlob(e) {
+	if (typeof e == "string") return e;
+	if (typeof e != "object" || !e) return;
+	let r = e;
+	if (typeof r.cid == "string") return r.cid;
+	if (typeof r.ref == "object" && r.ref !== null) {
+		let e = r.ref.$link;
+		if (typeof e == "string") return e;
+	}
+}
+function extractCidFromCdnUrl(r) {
+	if (r) return r.match(CID_PATTERN)?.[1];
+}
+export { extractCidFromBlob, extractCidFromCdnUrl, getBlobImageUrl, isBlobWithCdn };

package/dist/utils/profile.d.ts

@@ -0,0 +1,2 @@
+import type { ProfileRecord } from "../types/bluesky";
+export declare function getAvatarCid(record: ProfileRecord | undefined): string | undefined;

package/dist/utils/profile.js

@@ -0,0 +1,5 @@
+function getAvatarCid(e) {
+	let t = e?.avatar;
+	if (t) return typeof t.cid == "string" ? t.cid : t.ref?.$link;
+}
+export { getAvatarCid };

package/dist/utils/richtext.d.ts

@@ -0,0 +1,28 @@
+import type { AppBskyRichtextFacet } from "@atcute/bluesky";
+export type BlueskyRichTextFacet = AppBskyRichtextFacet.Main;
+export interface TextSegment {
+    text: string;
+    facet?: BlueskyRichTextFacet;
+}
+export type RichTextSegmentKind = "text" | "link" | "mention" | "tag";
+export interface RichTextSegment {
+    text: string;
+    kind: RichTextSegmentKind;
+    href?: string;
+    facet?: BlueskyRichTextFacet;
+    feature?: BlueskyRichTextFacet["features"][number];
+}
+export interface RichTextSegmentOptions {
+    blueskyAppBaseUrl?: string;
+}
+/**
+ * Converts a text string with facets into segments that can be rendered
+ * with appropriate styling and interactivity.
+ */
+export declare function createTextSegments(text: string, facets?: BlueskyRichTextFacet[]): TextSegment[];
+/**
+ * Converts Bluesky richtext facets into render-ready segments.
+ * Framework packages should map linked segments to anchors and plain segments
+ * to text nodes; feature interpretation stays centralized here.
+ */
+export declare function createRichTextSegments(text: string, facets?: BlueskyRichTextFacet[], options?: RichTextSegmentOptions): RichTextSegment[];

package/dist/utils/richtext.js

@@ -0,0 +1,95 @@
+function createTextSegments(e, t) {
+	if (!t || t.length === 0) return [{ text: e }];
+	let a = buildBytePrefix(e), o = [...t].sort((e, t) => e.index.byteStart - t.index.byteStart), s = [], c = 0;
+	for (let t of o) {
+		let n = byteOffsetToCharIndex(a, t.index.byteStart), o = byteOffsetToCharIndex(a, t.index.byteEnd);
+		n > c && s.push({ text: sliceByCharRange(e, c, n) }), s.push({
+			text: sliceByCharRange(e, n, o),
+			facet: t
+		}), c = o;
+	}
+	return c < e.length && s.push({ text: sliceByCharRange(e, c, e.length) }), s;
+}
+function createRichTextSegments(t, n, r = {}) {
+	let i = (r.blueskyAppBaseUrl ?? "https://bsky.app").replace(/\/+$/, "");
+	return createTextSegments(t, n).map((e) => {
+		let t = e.facet?.features?.[0];
+		if (!t) return {
+			...e,
+			kind: "text"
+		};
+		let n = t.$type;
+		if (n === "app.bsky.richtext.facet#link") {
+			let n = t.uri;
+			return n ? {
+				...e,
+				kind: "link",
+				href: n,
+				feature: t
+			} : {
+				...e,
+				kind: "text",
+				feature: t
+			};
+		}
+		if (n === "app.bsky.richtext.facet#mention") {
+			let n = t.did;
+			return n ? {
+				...e,
+				kind: "mention",
+				href: `${i}/profile/${n}`,
+				feature: t
+			} : {
+				...e,
+				kind: "text",
+				feature: t
+			};
+		}
+		if (n === "app.bsky.richtext.facet#tag") {
+			let n = t.tag;
+			return n ? {
+				...e,
+				kind: "tag",
+				href: `${i}/hashtag/${encodeURIComponent(n)}`,
+				feature: t
+			} : {
+				...e,
+				kind: "text",
+				feature: t
+			};
+		}
+		return {
+			...e,
+			kind: "text",
+			feature: t
+		};
+	});
+}
+function buildBytePrefix(e) {
+	let t = new TextEncoder(), n = [0], r = 0;
+	for (let i = 0; i < e.length;) {
+		let a = e.codePointAt(i);
+		if (a === void 0) break;
+		let o = String.fromCodePoint(a), s = t.encode(o);
+		r += s.length, n.push(r), i += a > 65535 ? 2 : 1;
+	}
+	return n;
+}
+function byteOffsetToCharIndex(e, t) {
+	for (let n = 0; n < e.length; n++) {
+		if (e[n] === t) return n;
+		if (e[n] > t) return Math.max(0, n - 1);
+	}
+	return e.length - 1;
+}
+function sliceByCharRange(e, t, n) {
+	if (t <= 0 && n >= e.length) return e;
+	let r = "", i = 0;
+	for (let a = 0; a < e.length && i < n;) {
+		let o = e.codePointAt(a);
+		if (o === void 0) break;
+		i >= t && i < n && (r += String.fromCodePoint(o)), a += o > 65535 ? 2 : 1, i++;
+	}
+	return r;
+}
+export { createRichTextSegments, createTextSegments };

package/dist/utils/time.d.ts

@@ -0,0 +1,2 @@
+/** Formats an ISO timestamp as a localized relative time (e.g. "3 hours ago"). */
+export declare function formatRelativeTime(iso: string): string;

package/dist/utils/time.js

@@ -0,0 +1,41 @@
+function formatRelativeTime(e) {
+	let t = (new Date(e).getTime() - Date.now()) / 1e3, n = Math.abs(t), r = [
+		{
+			limit: 60,
+			unit: "second",
+			divisor: 1
+		},
+		{
+			limit: 3600,
+			unit: "minute",
+			divisor: 60
+		},
+		{
+			limit: 86400,
+			unit: "hour",
+			divisor: 3600
+		},
+		{
+			limit: 604800,
+			unit: "day",
+			divisor: 86400
+		},
+		{
+			limit: 2629800,
+			unit: "week",
+			divisor: 604800
+		},
+		{
+			limit: 31557600,
+			unit: "month",
+			divisor: 2629800
+		},
+		{
+			limit: Infinity,
+			unit: "year",
+			divisor: 31557600
+		}
+	], i = r.find((e) => n < e.limit) ?? r[r.length - 1], a = t / i.divisor;
+	return new Intl.RelativeTimeFormat("en", { numeric: "auto" }).format(Math.round(a), i.unit);
+}
+export { formatRelativeTime };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@atproto-ui/core",
+  "version": "0.13.0",
+  "type": "module",
+  "description": "Framework-agnostic AT Protocol utilities: cache, client, types, and helpers.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.json --emitDeclarationOnly",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@atcute/atproto": "^4.0.0",
+    "@atcute/bluesky": "^4.0.2",
+    "@atcute/client": "^5.0.0",
+    "@atcute/identity": "^2.0.0",
+    "@atcute/identity-resolver": "^2.0.0",
+    "@atcute/lexicons": "^2.0.0",
+    "@atcute/tangled": "^2.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.4",
+    "typescript": "~5.9.3",
+    "unplugin-dts": "^1.0.1",
+    "vite": "npm:rolldown-vite@7.1.14"
+  }
+}