@qilin-agent/attachment 0.0.0-stage → 3.1.3

package/lib/types/index.d.ts

@@ -0,0 +1,132 @@
+/** Durable attachment storage seam (`ctx.attachments`). @module @qilin-agent/attachment */
+import { Context, Service } from '@qilin-agent/kylin';
+import { AttachmentError } from './error.ts';
+import type { AdmittedPromptContentPart, AttachmentAdmissionPart, EncodedFileAttachment, FileAttachmentRef, ImageAttachmentLimits, ImageAttachmentRef, ImageRequestTarget, RequestImageAttachment, SaveFileAttachment, SaveFileStreamAttachment, SaveImageAttachment, StoredImageAttachment } from './types.ts';
+export { AttachmentId, ImageVariantId } from './brand.ts';
+export { AttachmentError, isAttachmentError, isImageAdmissionError } from './error.ts';
+export type { AttachmentErrorCode, ImageAdmissionErrorCode } from './error.ts';
+export { admitEncodedFile, admitEncodedImages } from './admission.ts';
+export { longEdgeDimensions, requestImageDimensions } from './request-projection.ts';
+export type { ProjectedDimensions } from './request-projection.ts';
+export type { AttachmentId as AttachmentIdType, AdmittedPromptContentPart, AttachmentAdmissionPart, EncodedFileAttachment, EncodedImageAttachment, FileAttachmentRef, ImageAttachmentLimits, ImageAttachmentRef, ImageRequestTarget, ImageMediaType, PromptContentPart, RequestImageAttachment, SaveFileAttachment, SaveFileStreamAttachment, SaveImageAttachment, StoredImageAttachment, } from './types.ts';
+declare module '@qilin-agent/kylin' {
+    interface Context {
+        attachments: AttachmentStore;
+    }
+}
+/** Immutable binary attachment service. Implementations validate bytes before publishing a reference. */
+export declare abstract class AttachmentStore extends Service {
+    constructor(ctx: Context);
+    /** Deployment-resolved image policy used by authoritative and fast-path validation. */
+    abstract readonly imageLimits: ImageAttachmentLimits;
+    /**
+     * Validate one image without persisting it.
+     * Batch callers validate every member before saving any member.
+     * @param input - encoded bytes, declared media type, and optional display name.
+     * @returns completion after the encoded raster has been fully decoded.
+     */
+    abstract validateImage(input: SaveImageAttachment): Promise<void>;
+    /**
+     * Validate one ordered image batch before committing any member.
+     * Validation failures start no writes; storage failures return no partial
+     * references, although already published content-addressed objects may stay
+     * unreachable until a future retention policy collects them.
+     * @param inputs - encoded images in their owning message order.
+     * @returns durable references in the exact input order.
+     */
+    protected validateImageBatch(inputs: readonly SaveImageAttachment[]): void;
+    /**
+     * Validate and durably commit one ordered image batch.
+     * @param inputs - encoded images in owning-message order.
+     * @returns durable normalized attachment references in the same order after every member succeeds.
+     */
+    saveImages(inputs: readonly SaveImageAttachment[]): Promise<readonly ImageAttachmentRef[]>;
+    /**
+     * Admit one Host prompt and replace each uploaded image with its durable reference.
+     * Text and durable file references pass through unchanged. A prompt without image parts performs no storage operation.
+     * @param content - prompt parts in message order after file receipt resolution.
+     * @returns admitted prompt parts in the same order as `content`.
+     * @throws AttachmentError when the image batch is refused.
+     */
+    admitPromptContent(content: readonly AttachmentAdmissionPart[]): Promise<AdmittedPromptContentPart[]>;
+    /**
+     * Decode and durably commit one canonical base64 file upload.
+     * @param input - canonical base64 bytes and optional display name.
+     * @returns the durable content-addressed file reference.
+     * @throws AttachmentError when the encoding or storage operation is refused.
+     */
+    admitEncodedFile(input: EncodedFileAttachment): Promise<FileAttachmentRef>;
+    /**
+     * Identify a failure emitted by this attachment capability by its stable code.
+     * @param error - value caught from an attachment operation.
+     * @returns whether the value is an attachment failure.
+     */
+    isAttachmentError(error: unknown): error is AttachmentError;
+    /**
+     * Validate and durably commit one image before its owning session event is appended.
+     * The returned reference describes the persisted normalized image. When
+     * normalization reduces the raster, its `originalDimensions` records the
+     * orientation-applied input dimensions.
+     * @param input - encoded bytes, declared media type, and optional display name.
+     * @returns the durable content-addressed normalized image reference.
+     */
+    abstract saveImage(input: SaveImageAttachment): Promise<ImageAttachmentRef>;
+    /**
+     * Read one image and verify that bytes still match the recorded reference.
+     * @param ref - durable reference from the session log.
+     * @param signal - optional cancellation for backend read and verification work.
+     * @returns the verified bytes and normalized attachment reference.
+     * @throws the signal reason when aborted, or a storage error when verification fails.
+     */
+    abstract readImage(ref: ImageAttachmentRef, signal?: AbortSignal): Promise<StoredImageAttachment>;
+    /**
+     * Locate the provider-owned normalized object in the harness host filesystem.
+     * @param ref - durable normalized attachment reference.
+     * @returns an absolute host path, or undefined when this backend is not host-file-backed.
+     * @throws an AttachmentError when the durable reference is invalid.
+     */
+    imageHostPath(ref: ImageAttachmentRef): string | undefined;
+    /**
+     * Durably commit one file byte-for-byte before its owning session event is
+     * appended. Files carry no admission limits: any byte content and length is
+     * accepted, and the stored object is the exact submitted bytes. Backends
+     * without verbatim file storage keep this default rejection.
+     * @param input - exact bytes and optional display name.
+     * @returns the durable content-addressed file reference.
+     */
+    saveFile(input: SaveFileAttachment): Promise<FileAttachmentRef>;
+    /**
+     * Durably commit one file byte-for-byte from bounded chunks. Providers must
+     * apply backpressure and must not collect the complete file in memory.
+     * Backends without streamed verbatim storage keep this default rejection.
+     * @param input - ordered exact bytes, optional cancellation, and display name.
+     * @returns the durable content-addressed file reference.
+     */
+    saveFileStream(input: SaveFileStreamAttachment): Promise<FileAttachmentRef>;
+    /**
+     * Read and verify one verbatim stored file as bounded chunks. Providers must
+     * not collect the complete file in memory. Backends without verbatim file
+     * reads keep this default rejection.
+     * @param ref - durable reference from the session log.
+     * @param signal - optional cancellation for backend reads and verification work.
+     * @returns exact file bytes in order; integrity failures reject the iteration.
+     */
+    readFileStream(ref: FileAttachmentRef, signal?: AbortSignal): AsyncIterable<Uint8Array>;
+    /**
+     * Locate the verbatim stored file object in the harness host filesystem.
+     * @param ref - durable file reference.
+     * @returns an absolute host path, or undefined when this backend is not host-file-backed.
+     * @throws an AttachmentError when the durable reference is invalid.
+     */
+    fileHostPath(ref: FileAttachmentRef): string | undefined;
+    /**
+     * Generate or read one deterministic model-request version from the stored normalized image.
+     * @param ref - durable provider-independent normalized attachment reference.
+     * @param target - route-chosen dimensions and byte target; an unmet byte target yields the smallest ladder output.
+     * @param signal - optional cancellation.
+     * @returns request bytes and the cache/upload identity covering every transform input.
+     */
+    readImageRequest(ref: ImageAttachmentRef, target: ImageRequestTarget, signal?: AbortSignal): Promise<RequestImageAttachment>;
+}
+export default AttachmentStore;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,162 @@
+/** Durable attachment storage seam (`ctx.attachments`). @module @qilin-agent/attachment */
+import { Service } from '@qilin-agent/kylin';
+import { admitEncodedFile as admitFileInput, admitEncodedImages } from "./admission.js";
+import { AttachmentError, isAttachmentError as matchesAttachmentError } from "./error.js";
+export { AttachmentId, ImageVariantId } from "./brand.js";
+export { AttachmentError, isAttachmentError, isImageAdmissionError } from "./error.js";
+export { admitEncodedFile, admitEncodedImages } from "./admission.js";
+export { longEdgeDimensions, requestImageDimensions } from "./request-projection.js";
+/** Immutable binary attachment service. Implementations validate bytes before publishing a reference. */
+export class AttachmentStore extends Service {
+    constructor(ctx) {
+        super(ctx, 'attachments');
+    }
+    /**
+     * Validate one ordered image batch before committing any member.
+     * Validation failures start no writes; storage failures return no partial
+     * references, although already published content-addressed objects may stay
+     * unreachable until a future retention policy collects them.
+     * @param inputs - encoded images in their owning message order.
+     * @returns durable references in the exact input order.
+     */
+    validateImageBatch(inputs) {
+        const { maxImagesPerMessage, maxMessageImageBytes, mediaTypes } = this.imageLimits;
+        if (inputs.length > maxImagesPerMessage) {
+            throw new AttachmentError('Image batch exceeds the configured image-count limit.', 'TOO_MANY_IMAGES');
+        }
+        const totalBytes = inputs.reduce((sum, input) => sum + input.data.byteLength, 0);
+        if (totalBytes > maxMessageImageBytes) {
+            throw new AttachmentError('Image batch exceeds the configured aggregate image-byte limit.', 'IMAGES_TOO_LARGE');
+        }
+        for (const input of inputs) {
+            if (!mediaTypes.includes(input.mediaType)) {
+                throw new AttachmentError(`Image type ${input.mediaType} is not accepted by this deployment.`, 'UNSUPPORTED_IMAGE_TYPE');
+            }
+        }
+    }
+    /**
+     * Validate and durably commit one ordered image batch.
+     * @param inputs - encoded images in owning-message order.
+     * @returns durable normalized attachment references in the same order after every member succeeds.
+     */
+    async saveImages(inputs) {
+        this.validateImageBatch(inputs);
+        for (const input of inputs)
+            await this.validateImage(input);
+        const refs = [];
+        for (const input of inputs)
+            refs.push(await this.saveImage(input));
+        return refs;
+    }
+    /**
+     * Admit one Host prompt and replace each uploaded image with its durable reference.
+     * Text and durable file references pass through unchanged. A prompt without image parts performs no storage operation.
+     * @param content - prompt parts in message order after file receipt resolution.
+     * @returns admitted prompt parts in the same order as `content`.
+     * @throws AttachmentError when the image batch is refused.
+     */
+    async admitPromptContent(content) {
+        if (content.every(part => part.type !== 'image')) {
+            return content.map(part => part.type === 'text'
+                ? { type: 'text', text: part.text }
+                : { type: 'file', attachment: part.attachment });
+        }
+        const refs = await admitEncodedImages(this, content.filter(part => part.type === 'image'));
+        let next = 0;
+        return content.map((part) => {
+            if (part.type === 'text')
+                return { type: 'text', text: part.text };
+            if (part.type === 'file')
+                return { type: 'file', attachment: part.attachment };
+            return { type: 'image', attachment: refs[next++] };
+        });
+    }
+    /**
+     * Decode and durably commit one canonical base64 file upload.
+     * @param input - canonical base64 bytes and optional display name.
+     * @returns the durable content-addressed file reference.
+     * @throws AttachmentError when the encoding or storage operation is refused.
+     */
+    admitEncodedFile(input) {
+        return admitFileInput(this, input);
+    }
+    /**
+     * Identify a failure emitted by this attachment capability by its stable code.
+     * @param error - value caught from an attachment operation.
+     * @returns whether the value is an attachment failure.
+     */
+    isAttachmentError(error) {
+        return matchesAttachmentError(error);
+    }
+    /**
+     * Locate the provider-owned normalized object in the harness host filesystem.
+     * @param ref - durable normalized attachment reference.
+     * @returns an absolute host path, or undefined when this backend is not host-file-backed.
+     * @throws an AttachmentError when the durable reference is invalid.
+     */
+    imageHostPath(ref) {
+        void ref;
+        return undefined;
+    }
+    /**
+     * Durably commit one file byte-for-byte before its owning session event is
+     * appended. Files carry no admission limits: any byte content and length is
+     * accepted, and the stored object is the exact submitted bytes. Backends
+     * without verbatim file storage keep this default rejection.
+     * @param input - exact bytes and optional display name.
+     * @returns the durable content-addressed file reference.
+     */
+    saveFile(input) {
+        void input;
+        return Promise.reject(new AttachmentError('The mounted attachment provider cannot store verbatim files.', 'ATTACHMENT_FILES_UNSUPPORTED'));
+    }
+    /**
+     * Durably commit one file byte-for-byte from bounded chunks. Providers must
+     * apply backpressure and must not collect the complete file in memory.
+     * Backends without streamed verbatim storage keep this default rejection.
+     * @param input - ordered exact bytes, optional cancellation, and display name.
+     * @returns the durable content-addressed file reference.
+     */
+    saveFileStream(input) {
+        void input;
+        return Promise.reject(new AttachmentError('The mounted attachment provider cannot stream verbatim files.', 'ATTACHMENT_FILES_UNSUPPORTED'));
+    }
+    /**
+     * Read and verify one verbatim stored file as bounded chunks. Providers must
+     * not collect the complete file in memory. Backends without verbatim file
+     * reads keep this default rejection.
+     * @param ref - durable reference from the session log.
+     * @param signal - optional cancellation for backend reads and verification work.
+     * @returns exact file bytes in order; integrity failures reject the iteration.
+     */
+    async *readFileStream(ref, signal) {
+        signal?.throwIfAborted();
+        void ref;
+        await Promise.reject(new AttachmentError('The mounted attachment provider cannot read verbatim files.', 'ATTACHMENT_FILES_UNSUPPORTED'));
+    }
+    /**
+     * Locate the verbatim stored file object in the harness host filesystem.
+     * @param ref - durable file reference.
+     * @returns an absolute host path, or undefined when this backend is not host-file-backed.
+     * @throws an AttachmentError when the durable reference is invalid.
+     */
+    fileHostPath(ref) {
+        void ref;
+        return undefined;
+    }
+    /**
+     * Generate or read one deterministic model-request version from the stored normalized image.
+     * @param ref - durable provider-independent normalized attachment reference.
+     * @param target - route-chosen dimensions and byte target; an unmet byte target yields the smallest ladder output.
+     * @param signal - optional cancellation.
+     * @returns request bytes and the cache/upload identity covering every transform input.
+     */
+    readImageRequest(ref, target, signal) {
+        signal?.throwIfAborted();
+        void ref;
+        void target;
+        return Promise.reject(new AttachmentError('The mounted attachment provider cannot derive model-request images.', 'ATTACHMENT_PROJECTION_UNSUPPORTED'));
+    }
+}
+export default AttachmentStore;
+//# sourceMappingURL=index.js.map

package/lib/types/request-projection.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pure request-projection geometry shared by model routes and provider-side
+ * request pricing. @module @qilin-agent/attachment/request-projection
+ */
+/** Integer width and height of one projected image. */
+export interface ProjectedDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * Compute aspect-preserving integer dimensions within a hard total-pixel budget.
+ * @param width - positive source width.
+ * @param height - positive source height.
+ * @param maxPixels - positive width-times-height cap.
+ * @returns inward-rounded dimensions; small images are not enlarged.
+ */
+export declare function requestImageDimensions(width: number, height: number, maxPixels: number): ProjectedDimensions;
+/**
+ * Compute aspect-preserving integer dimensions with an exact long edge; the
+ * short edge rounds to the nearest pixel, as an encoder resize by the
+ * long edge alone.
+ * @param width - positive source width.
+ * @param height - positive source height.
+ * @param longEdge - positive target for the longer source edge.
+ * @returns the target dimensions; a long edge at or above the source returns the source unchanged.
+ */
+export declare function longEdgeDimensions(width: number, height: number, longEdge: number): ProjectedDimensions;
+//# sourceMappingURL=request-projection.d.ts.map

package/lib/types/request-projection.js

@@ -0,0 +1,49 @@
+/**
+ * Pure request-projection geometry shared by model routes and provider-side
+ * request pricing. @module @qilin-agent/attachment/request-projection
+ */
+/**
+ * Compute aspect-preserving integer dimensions within a hard total-pixel budget.
+ * @param width - positive source width.
+ * @param height - positive source height.
+ * @param maxPixels - positive width-times-height cap.
+ * @returns inward-rounded dimensions; small images are not enlarged.
+ */
+export function requestImageDimensions(width, height, maxPixels) {
+    const scale = Math.min(1, Math.sqrt(maxPixels / (width * height)));
+    if (scale === 1)
+        return { width, height };
+    if (width >= height) {
+        let projectedWidth = Math.max(1, Math.floor(width * scale));
+        let projectedHeight = Math.max(1, Math.round(projectedWidth * height / width));
+        while (projectedWidth * projectedHeight > maxPixels && projectedWidth > 1) {
+            projectedWidth -= 1;
+            projectedHeight = Math.max(1, Math.round(projectedWidth * height / width));
+        }
+        return { width: projectedWidth, height: projectedHeight };
+    }
+    let projectedHeight = Math.max(1, Math.floor(height * scale));
+    let projectedWidth = Math.max(1, Math.round(projectedHeight * width / height));
+    while (projectedWidth * projectedHeight > maxPixels && projectedHeight > 1) {
+        projectedHeight -= 1;
+        projectedWidth = Math.max(1, Math.round(projectedHeight * width / height));
+    }
+    return { width: projectedWidth, height: projectedHeight };
+}
+/**
+ * Compute aspect-preserving integer dimensions with an exact long edge; the
+ * short edge rounds to the nearest pixel, as an encoder resize by the
+ * long edge alone.
+ * @param width - positive source width.
+ * @param height - positive source height.
+ * @param longEdge - positive target for the longer source edge.
+ * @returns the target dimensions; a long edge at or above the source returns the source unchanged.
+ */
+export function longEdgeDimensions(width, height, longEdge) {
+    if (longEdge >= Math.max(width, height))
+        return { width, height };
+    return width >= height
+        ? { width: longEdge, height: Math.max(1, Math.round(longEdge * height / width)) }
+        : { width: Math.max(1, Math.round(longEdge * width / height)), height: longEdge };
+}
+//# sourceMappingURL=request-projection.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,155 @@
+/** Durable attachment vocabulary. @module @qilin-agent/attachment/types */
+import type { AttachmentId, ImageVariantId } from './brand.ts';
+export type { AttachmentId } from './brand.ts';
+/** Raster image formats accepted by the version-one attachment path. */
+export type ImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+/** Durable, serializable reference to one immutable normalized image. */
+export interface ImageAttachmentRef {
+    /** Opaque storage identifier; never a filesystem path or bearer URL. */
+    attachmentId: AttachmentId;
+    /** Media type verified from the stored bytes. */
+    mediaType: ImageMediaType;
+    /** Exact encoded byte length. */
+    bytes: number;
+    /** Intrinsic encoded width in pixels. */
+    width: number;
+    /** Intrinsic encoded height in pixels. */
+    height: number;
+    /** Optional display name stripped of local path information. */
+    name?: string;
+    /**
+     * Input dimensions after applying EXIF orientation and before normalization
+     * scaling. Present only when normalization reduced the image.
+     */
+    originalDimensions?: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Durable, serializable reference to one verbatim stored file. Files are
+ * stored byte-for-byte with no normalization; `attachmentId` is the sha256
+ * digest of exactly those bytes.
+ */
+export interface FileAttachmentRef {
+    /** Opaque content-addressed storage identifier; never a filesystem path or bearer URL. */
+    attachmentId: AttachmentId;
+    /** Sanitized display filename, also the stored object's leaf name. */
+    name: string;
+    /** Exact byte length. */
+    bytes: number;
+}
+/** Base64-encoded file upload accompanying one wire request. */
+export interface EncodedFileAttachment {
+    /** Canonical base64 encoding of the file bytes. */
+    data: string;
+    /** Optional display name; it is never interpreted as a path. */
+    name?: string;
+}
+/** Request to durably commit one file verbatim. */
+export interface SaveFileAttachment {
+    data: Uint8Array;
+    /** Optional browser/provider display name; it is never interpreted as a path. */
+    name?: string;
+}
+/** Request to durably commit one file from bounded byte chunks. */
+export interface SaveFileStreamAttachment {
+    /** Exact file bytes in order; providers must not retain the complete sequence in memory. */
+    data: AsyncIterable<Uint8Array>;
+    /** Optional cancellation for source reads and storage writes. */
+    signal?: AbortSignal;
+    /** Optional browser/provider display name; it is never interpreted as a path. */
+    name?: string;
+}
+/** Deployment-resolved limits used by upload admission and request buffering. */
+export interface ImageAttachmentLimits {
+    maxImageBytes: number;
+    maxImagesPerMessage: number;
+    maxMessageImageBytes: number;
+    maxImagePixels: number;
+    /** Maximum intrinsic width and maximum intrinsic height in pixels for one image. */
+    maxImageDimension: number;
+    mediaTypes: readonly ImageMediaType[];
+}
+/** Base64-encoded image upload accompanying one wire request. */
+export interface EncodedImageAttachment {
+    /** Declared media type, verified against the decoded bytes during admission. */
+    mediaType: ImageMediaType;
+    /** Canonical base64 encoding of the image bytes. */
+    data: string;
+    /** Optional display name; it is never interpreted as a path. */
+    name?: string;
+}
+/**
+ * Browser-submitted prompt content accepted by Host prompt endpoints; the
+ * accepting Host promotes image parts to durable references through
+ * `ctx.attachments.admitPromptContent()` before any message is created, so a wire caller can
+ * never cite an attachment it did not upload.
+ */
+export type PromptContentPart = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'image';
+    readonly mediaType: ImageMediaType;
+    readonly data: string;
+    readonly name?: string;
+};
+/** Host prompt content whose file receipts are resolved and whose image bytes await admission. */
+export type AttachmentAdmissionPart = PromptContentPart | {
+    readonly type: 'file';
+    readonly attachment: FileAttachmentRef;
+};
+/** Host-admitted prompt content with every attachment represented by its durable reference. */
+export type AdmittedPromptContentPart = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'image';
+    readonly attachment: ImageAttachmentRef;
+} | {
+    readonly type: 'file';
+    readonly attachment: FileAttachmentRef;
+};
+/** Request to validate and durably commit one image. */
+export interface SaveImageAttachment {
+    data: Uint8Array;
+    /** Caller-declared media type, checked against fully decoded bytes. */
+    mediaType: ImageMediaType;
+    /** Optional browser/provider display name; it is never interpreted as a path. */
+    name?: string;
+}
+/** Stored image bytes returned after reference and digest verification. */
+export interface StoredImageAttachment {
+    ref: ImageAttachmentRef;
+    data: Uint8Array;
+}
+/** Deterministic request-image target selected by one exact model route for one attachment. */
+export interface ImageRequestTarget {
+    /** Target width in pixels; a target above the source keeps the source width. */
+    width: number;
+    /** Target height in pixels; a target above the source keeps the source height. */
+    height: number;
+    /** Encoded-byte target before base64 expansion or Files API upload; the smallest quality-ladder output is kept when no quality fits. */
+    maxBytes: number;
+}
+/** Cached request version derived from one provider-independent normalized attachment. */
+export interface RequestImageAttachment {
+    /** Cache and upload-index key over the attachment id, policy, and fixed encoder parameters. */
+    variantId: ImageVariantId;
+    /** Durable normalized attachment from which this request version was derived. */
+    attachment: ImageAttachmentRef;
+    /** Encoded request bytes. */
+    data: Uint8Array;
+    mediaType: ImageMediaType;
+    bytes: number;
+    width: number;
+    height: number;
+    /** Provider-compatible sample depth proven after request encoding. */
+    depth: 'uchar';
+    /** Provider-compatible color space proven after request encoding. */
+    space: 'srgb';
+    /** Whether the encoded request version retains an alpha channel. */
+    hasAlpha: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,3 @@
+/** Durable attachment vocabulary. @module @qilin-agent/attachment/types */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@qilin-agent/attachment",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Durable immutable attachment storage seam for the QiLin",
+  "version": "3.1.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/attachment/attachment"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@qilin-agent/brand": "3.1.3",
+    "@qilin-agent/kylin": "~4.0.3"
+  },
+  "devDependencies": {
+    "@qilin-agent/brand": "3.1.3",
+    "@qilin-agent/kylin": "~4.0.3"
+  }
 }