@sentropic/artifacts 0.1.3 → 0.1.4

package/dist/server/publication-limits.js

@@ -0,0 +1,38 @@
+export const DEFAULT_PUBLICATION_LIMITS = Object.freeze({
+    maxFiles: 128, maxFileBytes: 16 * 1024 * 1024, maxTotalBytes: 64 * 1024 * 1024,
+});
+export function publicationLimits(overrides = {}) {
+    const limits = { ...DEFAULT_PUBLICATION_LIMITS, ...overrides };
+    if (Object.values(limits).some((value) => !Number.isSafeInteger(value) || value <= 0)) {
+        throw new Error('invalid publication limits');
+    }
+    return Object.freeze(limits);
+}
+/** Validate before copying bytes, hashing, idempotency lookup or recording intents. */
+export function validatePublicationFiles(files, limits) {
+    if (!Array.isArray(files) || files.length === 0 || files.length > limits.maxFiles) {
+        throw new Error('invalid publication file count budget');
+    }
+    const paths = new Set();
+    let total = 0;
+    for (const file of files) {
+        if (typeof file.path !== 'string' || Buffer.byteLength(file.path) > 1024 ||
+            /[\\%?#:\u0000-\u001f\u007f]/.test(file.path) ||
+            file.path.split('/').some((part) => part === '' || part === '.' || part === '..')) {
+            throw new Error('invalid publication path');
+        }
+        if (paths.has(file.path))
+            throw new Error('duplicate publication path');
+        paths.add(file.path);
+        if (typeof file.mimeType !== 'string' || file.mimeType.length === 0 ||
+            file.mimeType.length > 256 || /[\u0000-\u001f\u007f]/.test(file.mimeType)) {
+            throw new Error('invalid publication MIME type');
+        }
+        if (!(file.bytes instanceof Uint8Array) || file.bytes.byteLength > limits.maxFileBytes) {
+            throw new Error('invalid publication file byte budget');
+        }
+        total += file.bytes.byteLength;
+        if (total > limits.maxTotalBytes)
+            throw new Error('invalid publication total byte budget');
+    }
+}

package/dist/server/publication.d.ts

@@ -1,6 +1,9 @@
 import type { JsonValue } from '../contracts.js';
 import type { IntentStore } from './object-intents.js';
 import type { IdempotencyStore } from './idempotency.js';
+import { type SourceRef, type SourceStore } from './sources.js';
+import { type PublicationLimits } from './publication-limits.js';
+export { DEFAULT_PUBLICATION_LIMITS, type PublicationLimits } from './publication-limits.js';
 export interface ReleaseRecord {
     releaseId: string;
     artifactId: string;
@@ -40,7 +43,9 @@ export interface PublishInput {
     artifactId: string;
     profile: Record<string, JsonValue | undefined>;
     files: PublicationFileInput[];
+    source?: SourceRef;
     idempotencyKey?: string;
+    /** @deprecated Ignored; the server hashes release metadata and file digests. */
     paramsHash?: string;
 }
 export interface PublishResult {
@@ -48,7 +53,9 @@ export interface PublishResult {
     manifest: string;
 }
 export interface PublicationService {
-    publish(input: PublishInput): Promise<PublishResult>;
+    readonly limits?: Readonly<PublicationLimits>;
+    /** The host source store participates in the idempotent commit when a source is supplied. */
+    publish(input: PublishInput, sources?: SourceStore): Promise<PublishResult>;
     getCurrent(artifactId: string): Promise<{
         releaseId: string;
         manifest: string;
@@ -64,4 +71,5 @@ export declare function createPublicationService(deps: {
     blobs: PublicationBlobStore;
     intents: IntentStore;
     idempotency?: IdempotencyStore;
+    limits?: Partial<PublicationLimits>;
 }): PublicationService;

package/dist/server/publication.js

@@ -13,6 +13,9 @@
  */
 import { createHash } from 'node:crypto';
 import { canonicalManifest, manifestDigest } from '../codecs.js';
+import { parseSourceRef } from './sources.js';
+import { publicationLimits, validatePublicationFiles } from './publication-limits.js';
+export { DEFAULT_PUBLICATION_LIMITS } from './publication-limits.js';
 /** Derive the `sha256:<hex>` digest from a digest-addressed blob key. */
 export function blobDigestOfKey(key) {
     const hex = key.split('/').pop() ?? '';
@@ -72,8 +75,8 @@ function shaHex(bytes) {
 }
 /** Create a publication service over injected stores (no driver imports). */
 export function createPublicationService(deps) {
-    async function commitOnce(input) {
-        const releaseId = crypto.randomUUID();
+    const limits = publicationLimits(deps.limits);
+    function prepare(input) {
         const entries = input.files.map((file) => {
             const hex = shaHex(file.bytes);
             return {
@@ -92,6 +95,11 @@ export function createPublicationService(deps) {
         };
         const digest = manifestDigest(body);
         const manifest = canonicalManifest({ ...body, digest });
+        return { entries, digest, manifest };
+    }
+    async function commitOnce(input, prepared, sources) {
+        const releaseId = crypto.randomUUID();
+        const { entries, digest, manifest } = prepared;
         const intent = await deps.intents.record('commit-release', {
             artifactId: input.artifactId,
             releaseId,
@@ -124,16 +132,26 @@ export function createPublicationService(deps) {
             await deps.intents.markFailed(intent.intentId, 'commit race lost: explicit conflict');
             throw new Error(`publication conflict for ${input.artifactId}: concurrent commit won`);
         }
+        if (input.source !== undefined)
+            await sources.putSource(input.artifactId, input.source);
         await deps.intents.complete(intent.intentId);
         return { releaseId, manifest };
     }
     return {
-        async publish(input) {
+        limits,
+        async publish(input, sources) {
+            validatePublicationFiles(input.files, limits);
+            const source = input.source === undefined ? undefined : parseSourceRef(input.source);
+            if (source !== undefined && sources === undefined)
+                throw new Error('invalid publication: missing source store');
+            input = { ...input, source, files: input.files.map((file) => ({ ...file, bytes: new Uint8Array(file.bytes) })) };
+            const prepared = prepare(input);
+            const requestHash = createHash('sha256').update(JSON.stringify([prepared.digest, source ?? null])).digest('hex');
             if (input.idempotencyKey !== undefined && deps.idempotency !== undefined) {
-                const { result } = await deps.idempotency.execute(input.idempotencyKey, input.paramsHash ?? '', () => commitOnce(input));
+                const { result } = await deps.idempotency.execute(JSON.stringify(['publish', input.ownerId, input.idempotencyKey]), requestHash, () => commitOnce(input, prepared, sources));
                 return result;
             }
-            return commitOnce(input);
+            return commitOnce(input, prepared, sources);
         },
         async getCurrent(artifactId) {
             const releaseId = await deps.state.getCurrentReleaseId(artifactId);

package/dist/server/service.d.ts

@@ -5,7 +5,10 @@ export interface EnsurePrivateViewInput {
     storageScopeId: string;
     bindingName: string;
     idempotencyKey: string;
-    paramsHash: string;
+    /** @deprecated Ignored; the service computes its own hash. */
+    paramsHash?: string;
+    /** Validated provider parameters supplied by the application layer. */
+    parameters?: Record<string, string | number | boolean | null>;
 }
 export interface EnsurePrivateViewResult {
     artifactId: string;

package/dist/server/service.js

@@ -10,6 +10,7 @@
 import { assertArtifactAccess } from './authorization.js';
 import { createBindingService } from './bindings.js';
 import { createIdempotencyStore } from './idempotency.js';
+import { manifestDigest } from '../codecs.js';
 /** Create the artifact service over explicit injected ports (no defaults). */
 export function createArtifactService(ports) {
     const bindings = createBindingService(ports.kv, ports.uuid);
@@ -21,7 +22,11 @@ export function createArtifactService(ports) {
                 artifactOwnerId: input.ownerId,
                 action: 'mutate',
             });
-            const { result, replayed } = await idempotent.execute(input.idempotencyKey, input.paramsHash, () => bindings.ensure({
+            const { result, replayed } = await idempotent.execute(JSON.stringify(['ensure', input.actorUserId, input.idempotencyKey]), manifestDigest({
+                schemaVersion: 'artifacts/v1', ownerId: input.ownerId,
+                storageScopeId: input.storageScopeId, bindingName: input.bindingName,
+                parameters: input.parameters ?? {},
+            }), () => bindings.ensure({
                 ownerId: input.ownerId,
                 storageScopeId: input.storageScopeId,
                 bindingName: input.bindingName,

package/dist/server/uploads.d.ts

@@ -20,10 +20,13 @@ export interface UploadService {
     begin(input: BeginUploadInput): Promise<{
         uploadId: string;
     }>;
+    /** Check that the session is open and optionally validate its sequential offset before decoding. */
+    remainingBytes(uploadId: string, offset?: number): number;
     append(uploadId: string, offset: number, chunk: Uint8Array): Promise<{
         size: number;
     }>;
-    commit(uploadId: string, expected: BlobRef): Promise<BlobRef>;
+    /** Validate the commit snapshot before consuming the session; rejected validation remains retryable. */
+    commit(uploadId: string, expected: BlobRef, validate?: (bytes: Uint8Array) => void): Promise<BlobRef>;
 }
 /** Create an upload service over an injected staging store (no S3 imports). */
 export declare function createUploadService(staging: StagingStore, options: UploadServiceOptions, ids?: () => string): UploadService;

package/dist/server/uploads.js

@@ -33,54 +33,82 @@ export function createMemoryStaging() {
 }
 /** Create an upload service over an injected staging store (no S3 imports). */
 export function createUploadService(staging, options, ids = () => crypto.randomUUID()) {
+    if (!Number.isSafeInteger(options.maxUploadBytes) || options.maxUploadBytes < 1) {
+        throw new Error('invalid upload byte budget');
+    }
     const sessions = new Map();
+    function openSession(uploadId) {
+        const session = sessions.get(uploadId);
+        if (session === undefined)
+            throw new Error(`unknown upload: ${uploadId}`);
+        if (session.committed)
+            throw new Error(`upload already committed: ${uploadId}`);
+        if (session.busy)
+            throw new Error(`upload conflict: operation in progress for ${uploadId}`);
+        return session;
+    }
+    async function exclusive(uploadId, run) {
+        const session = openSession(uploadId);
+        session.busy = true;
+        try {
+            return await run(session);
+        }
+        finally {
+            session.busy = false;
+        }
+    }
+    function remainingBytes(uploadId, offset) {
+        const session = openSession(uploadId);
+        if (offset !== undefined && (!Number.isSafeInteger(offset) || offset !== session.size)) {
+            throw new Error(`upload offset mismatch for ${uploadId}: expected ${session.size}, got ${offset}`);
+        }
+        return session.maxSize - session.size;
+    }
     return {
+        remainingBytes,
         async begin(input) {
+            if (input.maxSize !== undefined && (!Number.isSafeInteger(input.maxSize) || input.maxSize < 1)) {
+                throw new Error('invalid upload byte budget');
+            }
             const uploadId = ids();
             sessions.set(uploadId, {
                 committed: false,
-                maxSize: input.maxSize ?? options.maxUploadBytes,
+                busy: false,
+                maxSize: Math.min(input.maxSize ?? options.maxUploadBytes, options.maxUploadBytes),
                 size: 0,
             });
             await staging.write(uploadId, new Uint8Array(0));
             return { uploadId };
         },
         async append(uploadId, offset, chunk) {
-            const session = sessions.get(uploadId);
-            if (session === undefined)
-                throw new Error(`unknown upload: ${uploadId}`);
-            if (session.committed)
-                throw new Error(`upload already committed: ${uploadId}`);
-            if (offset !== session.size) {
-                throw new Error(`upload offset mismatch for ${uploadId}: expected ${session.size}, got ${offset}`);
-            }
-            if (session.size + chunk.length > session.maxSize) {
-                throw new Error(`upload budget exceeded for ${uploadId}: max ${session.maxSize} bytes`);
-            }
-            const current = await staging.read(uploadId);
-            const next = new Uint8Array(current.length + chunk.length);
-            next.set(current, 0);
-            next.set(chunk, current.length);
-            await staging.write(uploadId, next);
-            session.size = next.length;
-            return { size: session.size };
+            const remaining = remainingBytes(uploadId, offset);
+            return exclusive(uploadId, async (session) => {
+                if (chunk.length > remaining) {
+                    throw new Error(`upload budget exceeded for ${uploadId}: max ${session.maxSize} bytes`);
+                }
+                const current = await staging.read(uploadId);
+                const next = new Uint8Array(current.length + chunk.length);
+                next.set(current, 0);
+                next.set(chunk, current.length);
+                await staging.write(uploadId, next);
+                session.size = next.length;
+                return { size: session.size };
+            });
         },
-        async commit(uploadId, expected) {
-            const session = sessions.get(uploadId);
-            if (session === undefined)
-                throw new Error(`unknown upload: ${uploadId}`);
-            if (session.committed)
-                throw new Error(`upload already committed: ${uploadId}`);
-            const bytes = await staging.read(uploadId);
-            if (bytes.length !== expected.size) {
-                throw new Error(`upload size mismatch for ${uploadId}: staged ${bytes.length}, declared ${expected.size}`);
-            }
-            const actual = `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
-            if (actual !== expected.digest) {
-                throw new Error(`upload digest mismatch for ${uploadId}: staged ${actual}`);
-            }
-            session.committed = true;
-            return { digest: actual, size: bytes.length };
+        async commit(uploadId, expected, validate) {
+            return exclusive(uploadId, async (session) => {
+                const bytes = new Uint8Array(await staging.read(uploadId));
+                validate?.(bytes);
+                if (bytes.length !== expected.size) {
+                    throw new Error(`upload size mismatch for ${uploadId}: staged ${bytes.length}, declared ${expected.size}`);
+                }
+                const actual = `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+                if (actual !== expected.digest) {
+                    throw new Error(`upload digest mismatch for ${uploadId}: staged ${actual}`);
+                }
+                session.committed = true;
+                return { digest: actual, size: bytes.length };
+            });
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentropic/artifacts",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Generic configurable artifacts MCP and artifact service: StorageScope/Artifact/Binding/Release model, canonical manifests, object authorization, idempotent intents (spec-v8 §9).",
   "type": "module",
   "license": "MIT",
@@ -101,6 +101,10 @@
       "types": "./dist/mcp.d.ts",
       "import": "./dist/mcp.js"
     },
+    "./mcp-core": {
+      "types": "./dist/mcp-core.d.ts",
+      "import": "./dist/mcp-core.js"
+    },
     "./content/grants": {
       "types": "./dist/content/grants.d.ts",
       "import": "./dist/content/grants.js"