@sentropic/artifacts 0.2.4 → 0.2.6

package/dist/server/result-schema.js

@@ -0,0 +1,35 @@
+/** Published domain-result envelope; error details are selected by code and variant. */
+const string = { type: 'string' };
+const nullable = { type: ['string', 'null'] };
+const object = (properties, required = Object.keys(properties)) => ({
+    type: 'object', properties, required, additionalProperties: false,
+});
+const error = (code, details) => object({
+    code: { enum: [code] }, message: string, retriable: { type: 'boolean' }, details,
+});
+const pointer = object({ variant: { enum: ['pointer_conflict'] }, artifactId: string,
+    expectedCurrentReleaseId: nullable, currentReleaseId: nullable, currentDigest: nullable,
+    currentSource: object({ artifactId: string, releaseId: string, digest: nullable,
+        manifest: string, files: { type: 'array', items: { type: 'object' } }, sourceRef: { type: ['object', 'null'] },
+        stableUrl: string, pinnedUrl: string }, ['artifactId', 'releaseId', 'digest', 'manifest', 'files', 'sourceRef']),
+}, ['variant', 'artifactId', 'expectedCurrentReleaseId', 'currentReleaseId', 'currentDigest']);
+const common = { invocationId: string,
+    commitState: { enum: ['not_committed', 'committed', 'unknown'] } };
+export const ARTIFACT_RESULT_SCHEMA = {
+    type: 'object',
+    oneOf: [
+        object({ ok: { enum: [true] }, ...common, replayed: { type: 'boolean' }, output: { type: 'object' } }),
+        object({ ok: { enum: [false] }, ...common, error: { oneOf: [
+                    error('conflict', { oneOf: [pointer, object({ variant: { enum: ['command_conflict', 'key_contention', 'quota_exhausted'] } })] }),
+                    error('edit_mismatch', object({ path: string, editIndex: { type: 'integer', minimum: 0 },
+                        reason: { enum: ['missing', 'ambiguous', 'not_text', 'file_missing'] }, occurrences: { type: 'integer' } })),
+                    error('release_unavailable', object({ reason: { enum: ['purged', 'not_retained', 'unpublished'] } })),
+                    error('precondition_required', object({ profileRevisionId: string, resultEnvelopeVersion: { enum: [1, 2] },
+                        requiredField: { enum: ['expectedCurrentReleaseId'] }, readTools: { type: 'array', items: string } })),
+                    error('confirmation_required', object({ confirmationRef: string, managementUrl: string, expiresAt: string })),
+                    object({ code: { type: 'string', not: { enum: ['conflict', 'edit_mismatch', 'release_unavailable',
+                                    'precondition_required', 'confirmation_required'] } },
+                        message: string, retriable: { type: 'boolean' }, details: object({ variant: string }) }, ['code', 'message', 'retriable']),
+                ] } }),
+    ],
+};

package/dist/server/service.d.ts

@@ -3,6 +3,7 @@ import { type CompiledArtifactsProfile } from '../profile/index.js';
 import { type ArtifactKeyDerivationBinding } from './command-identity.js';
 import type { ArtifactInvocationContext, ArtifactCommitCoordinator, FinalizeTxClient, InternalIdempotencyKey } from './commit/types.js';
 import type { ArtifactOutcome } from './failures.js';
+import type { ArtifactMetadata } from './access.js';
 export interface EnsurePrivateViewInput {
     actorUserId: string;
     ownerId: string;
@@ -48,6 +49,7 @@ export interface GuardedEnsureResult {
 }
 /** Binding identity resolved inside the finalization unit. */
 export interface EnsureBindingInput {
+    readonly metadata?: ArtifactMetadata;
     readonly ownerId: string;
     readonly storageScopeId: string;
     readonly bindingName: string;

package/dist/server/service.js

@@ -88,7 +88,9 @@ const ensureResult = (receipt, replayed, invocationId) => ({
 });
 export function createGuardedEnsureService(deps) {
     const finalizeRequest = (invocation, command, policyRevision) => {
+        const metadata = Object.fromEntries(['title', 'description', 'icon'].filter(key => Object.hasOwn(command.payload, key)).map(key => [key, command.payload[key]]));
         const binding = {
+            ...(Object.keys(metadata).length ? { metadata } : {}),
             ownerId: invocation.actorId,
             storageScopeId: invocation.storageScopeId,
             bindingName: command.payload.bindingName,

package/dist/server/source-read.d.ts

@@ -0,0 +1,38 @@
+import type { SourceRef } from './sources.js';
+import type { PublicationService } from './publication.js';
+export interface SourceReadPorts {
+    storageScopeId?: string;
+    authorize(): Promise<void>;
+    getCurrent: PublicationService['getCurrent'];
+    getRelease: PublicationService['getRelease'];
+    getSource(artifactId: string): Promise<SourceRef | undefined>;
+    getBlob(key: string): Promise<Uint8Array | undefined>;
+    urls?: (artifactId: string, releaseId: string) => {
+        stableUrl: string;
+        pinnedUrl: string;
+    };
+    maxFiles: number;
+    maxTotalBytes: number;
+}
+export interface SourceReadInput {
+    artifactId: string;
+    releaseId?: string;
+    paths?: readonly string[];
+}
+/** Read author bytes only. Provenance never substitutes for a stored snapshot. */
+export declare function readArtifactSource(ports: SourceReadPorts, input: SourceReadInput): Promise<{
+    stableUrl?: string | undefined;
+    pinnedUrl?: string | undefined;
+    artifactId: string;
+    releaseId: string;
+    digest: string;
+    manifest: string;
+    files: {
+        bytes: number[];
+        path: string;
+        mimeType: string;
+        digest: string;
+        size: number;
+    }[];
+    sourceRef: SourceRef | null;
+}>;

package/dist/server/source-read.js

@@ -0,0 +1,68 @@
+import { createHash } from 'node:crypto';
+import { parseManifest } from '../codecs.js';
+import { ArtifactOperationError } from './failures.js';
+/** Read author bytes only. Provenance never substitutes for a stored snapshot. */
+export async function readArtifactSource(ports, input) {
+    await ports.authorize();
+    const release = input.releaseId === undefined ? await ports.getCurrent(input.artifactId)
+        : await ports.getRelease(input.releaseId);
+    if (!release)
+        throw input.releaseId ? new ArtifactOperationError('not_found')
+            : new ArtifactOperationError('release_unavailable', { publicDetails: { reason: 'unpublished' } });
+    if ((input.releaseId !== undefined && release.releaseId !== input.releaseId) ||
+        release.artifactId !== input.artifactId)
+        throw new ArtifactOperationError('not_found');
+    let manifest;
+    try {
+        manifest = parseManifest(release.manifest);
+    }
+    catch (cause) {
+        throw new ArtifactOperationError('verification_failed', { cause });
+    }
+    if (manifest.artifactId !== input.artifactId)
+        throw new ArtifactOperationError('not_found');
+    if (ports.storageScopeId !== undefined && manifest.storageScopeId !== ports.storageScopeId)
+        throw new ArtifactOperationError('verification_failed');
+    if (release.manifestDigest !== manifest.digest)
+        throw new ArtifactOperationError('verification_failed');
+    if (release.state === 'purged')
+        throw new ArtifactOperationError('release_unavailable', { publicDetails: { reason: 'purged' } });
+    if (!manifest.digest || !Array.isArray(manifest.files) || manifest.files.length > ports.maxFiles) {
+        throw new ArtifactOperationError('verification_failed');
+    }
+    const entries = [];
+    const paths = new Set();
+    let total = 0;
+    for (const value of manifest.files) {
+        const file = value;
+        if (!file || typeof file.path !== 'string' || typeof file.mimeType !== 'string' ||
+            !/^sha256:[0-9a-f]{64}$/.test(file.digest) || !Number.isSafeInteger(file.size) || file.size < 0 ||
+            paths.has(file.path))
+            throw new ArtifactOperationError('verification_failed');
+        total += file.size;
+        if (total > ports.maxTotalBytes)
+            throw new ArtifactOperationError('limit_exceeded');
+        paths.add(file.path);
+        entries.push(file);
+    }
+    if (input.paths !== undefined && (!input.paths.length || input.paths.length > ports.maxFiles ||
+        new Set(input.paths).size !== input.paths.length || input.paths.some((path) => !paths.has(path)))) {
+        throw new ArtifactOperationError('invalid_request');
+    }
+    const selected = input.paths === undefined ? entries : entries.filter((file) => input.paths.includes(file.path));
+    const files = [];
+    for (const file of selected) {
+        const bytes = await ports.getBlob(`artifacts/${manifest.storageScopeId}/blobs/sha256/${file.digest.slice(7)}`);
+        if (!bytes)
+            throw new ArtifactOperationError('release_unavailable', { publicDetails: { reason: 'not_retained' } });
+        if (bytes.length !== file.size ||
+            createHash('sha256').update(bytes).digest('hex') !== file.digest.slice(7)) {
+            throw new ArtifactOperationError('verification_failed');
+        }
+        files.push({ ...file, bytes: Array.from(bytes) });
+    }
+    const sourceRef = await ports.getSource(input.artifactId) ?? null;
+    await ports.authorize();
+    return { artifactId: input.artifactId, releaseId: release.releaseId, digest: manifest.digest,
+        manifest: release.manifest, files, sourceRef, ...ports.urls?.(input.artifactId, release.releaseId) };
+}

package/dist/server/summary.d.ts

@@ -0,0 +1,40 @@
+import { type ArtifactAcl } from './access.js';
+export declare function artifactSummary(input: {
+    artifactId: string;
+    acl: ArtifactAcl;
+    actorId: string;
+    state: string;
+    current?: {
+        releaseId: string;
+        manifest: string;
+    };
+    urls?: (artifactId: string, releaseId: string) => {
+        stableUrl: string;
+        pinnedUrl: string;
+    };
+    approved?: (principalId: string) => boolean;
+}): {
+    permissions: {
+        read: boolean;
+        source: boolean;
+        write: boolean;
+        manage: boolean;
+    };
+    metadata?: import("./access.js").ArtifactMetadata | undefined;
+    artifactId: string;
+    bindingName: string | null;
+    ownerId: string;
+    storageScopeId: string | undefined;
+    state: string;
+    isPublic: boolean;
+    withdrawn: boolean;
+    createdAt: string | null;
+    updatedAt: string | null;
+    currentReleaseId: string | null;
+    digest: string | null;
+    stableUrl: string | null;
+    pinnedUrl: string | null;
+    title: string;
+    description: string;
+    icon: string | null;
+};

package/dist/server/summary.js

@@ -0,0 +1,18 @@
+import { parseManifest } from '../codecs.js';
+import { evaluateAccess } from './access.js';
+export function artifactSummary(input) {
+    const { artifactId, acl, actorId, state, current } = input;
+    const urls = input.urls?.(artifactId, current?.releaseId ?? '');
+    const owner = acl.ownerId === actorId;
+    return { artifactId, bindingName: acl.bindingName ?? null, ownerId: acl.ownerId,
+        storageScopeId: acl.storageScopeId, state, isPublic: acl.isPublic, withdrawn: state === 'withdrawn',
+        createdAt: acl.createdAt ?? null, updatedAt: acl.updatedAt ?? null,
+        currentReleaseId: current?.releaseId ?? null, digest: current ? parseManifest(current.manifest).digest ?? null : null,
+        stableUrl: urls?.stableUrl ?? null, pinnedUrl: current ? urls?.pinnedUrl ?? null : null,
+        title: acl.metadata?.title ?? acl.title ?? acl.bindingName ?? artifactId,
+        description: acl.metadata?.description ?? acl.description ?? '',
+        icon: acl.metadata?.icon !== undefined ? acl.metadata.icon : acl.icon ?? null,
+        ...(acl.metadata === undefined ? {} : { metadata: acl.metadata }),
+        permissions: { read: evaluateAccess(acl, actorId, 'read', input.approved),
+            source: evaluateAccess(acl, actorId, 'source', input.approved), write: owner, manage: owner } };
+}

package/dist/server/templates.js

@@ -44,11 +44,32 @@ const GUIDE_V1 = [
     'Publish and share static web pages through the `artifacts_*` tools:',
     '',
     '- `artifacts_get_template` / `artifacts_get_api_guide`: start here.',
-    '- `artifacts_ensure`: resolve (or create) your private artifact view.',
-    '- `artifacts_publish`: publish inline files as a new release.',
+    '- `artifacts_ensure`: resolve (or create) your private artifact view;',
+    '  optional `title`, `description` and `icon` (one short word) describe it.',
+    '- `artifacts_publish`: publish inline `files` as a new release, or apply',
+    '  small `edits` (`[{path, oldStr, newStr}]`) to the current release\'s',
+    '  text files — `oldStr` must occur exactly once per file, otherwise the',
+    '  call fails with `edit_mismatch` and changes nothing. Both accept',
+    '  optional metadata and `expectedCurrentReleaseId`: when set and not the',
+    '  current release, the call fails with a `conflict` error carrying the',
+    '  current release id and digest so you can re-read and merge.',
+    '  Strict profiles require this field on publish and revert; null means unpublished.',
+    '  Edits target that observed release, with at most 100 ordered substitutions.',
+    '  Reuse the exact idempotency key after a lost response, including commitState unknown.',
+    '  Replays precede edits and CAS; changing metadata, edits or the precondition under',
+    '  the same key returns conflict with variant command_conflict.',
+    '  MCP returns the complete artifacts-outcome/v2 JSON envelope: ok, invocationId,',
+    '  commitState, replayed/output on success, or typed error details on failure.',
     '- `artifacts_create_upload` + bounded HTTP append +',
     '  `artifacts_commit_upload`: stage large bytes, then commit them.',
-    '- `artifacts_list` / `artifacts_get` / `artifacts_get_source`: discover.',
+    '- `artifacts_list` / `artifacts_get`: discover (metadata included).',
+    '- `artifacts_list_versions`: full release history of one artifact —',
+    '  per release: id, created at, author, state, whether it is current,',
+    '  and a content digest.',
+    '- `artifacts_get_source`: current file contents (text decoded) for editing.',
+    '- `artifacts_revert`: make an earlier release current again as a NEW',
+    '  release that copies its content — the artifact URL stays stable and',
+    '  history only grows. Purged releases are refused with `release_unavailable`.',
     '- `artifacts_fork`: private independent copy (no ACL copied).',
     '- `artifacts_set_access`: grant/revoke read or source, toggle public.',
     '- `artifacts_promote`: explicit version selection (expected-current).',

package/dist/server/versions.d.ts

@@ -0,0 +1,29 @@
+import type { ReleaseRecord } from './publication.js';
+/** A cursor fixes the release boundary and is bound to the authorized artifact and scope. */
+export declare function artifactVersions(input: {
+    artifactId: string;
+    storageScopeId: string;
+    currentReleaseId: string | null;
+    releases: ReleaseRecord[];
+    limit?: number;
+    cursor?: string;
+    state(releaseId: string): Promise<string>;
+    urls?: (artifactId: string, releaseId: string) => {
+        pinnedUrl: string;
+    };
+}): Promise<{
+    artifactId: string;
+    currentReleaseId: string | null;
+    versions: {
+        releaseId: string;
+        createdAt: string;
+        state: string;
+        authorPrincipalId: string | null;
+        parentReleaseId: string | null;
+        revertedFromReleaseId: string | null;
+        digest: string;
+        isCurrent: boolean;
+        pinnedUrl: string | null;
+    }[];
+    nextCursor: string | null;
+}>;

package/dist/server/versions.js

@@ -0,0 +1,39 @@
+import { ArtifactOperationError } from './failures.js';
+const order = (a, b) => a.createdAt.localeCompare(b.createdAt) || a.releaseId.localeCompare(b.releaseId);
+/** A cursor fixes the release boundary and is bound to the authorized artifact and scope. */
+export async function artifactVersions(input) {
+    const releases = [...input.releases].sort((a, b) => order(b, a));
+    let snapshot = releases[0];
+    let after;
+    if (input.cursor !== undefined) {
+        try {
+            const parsed = JSON.parse(Buffer.from(input.cursor, 'base64url').toString('utf8'));
+            const position = (value) => value && typeof value.createdAt === 'string' &&
+                typeof value.releaseId === 'string' && releases.some(release => order(release, value) === 0);
+            if (parsed.artifactId !== input.artifactId || parsed.storageScopeId !== input.storageScopeId ||
+                !position(parsed.snapshot) || !position(parsed.after) || order(parsed.after, parsed.snapshot) > 0)
+                throw new Error();
+            snapshot = parsed.snapshot;
+            after = parsed.after;
+        }
+        catch {
+            throw new ArtifactOperationError('invalid_request');
+        }
+    }
+    const available = releases.filter(release => snapshot && order(release, snapshot) <= 0 &&
+        (!after || order(release, after) < 0));
+    const page = available.slice(0, input.limit ?? 20);
+    const versions = await Promise.all(page.map(async (release) => {
+        const state = await input.state(release.releaseId);
+        return { releaseId: release.releaseId, createdAt: release.createdAt, state,
+            authorPrincipalId: release.authorPrincipalId ?? null, parentReleaseId: release.parentReleaseId ?? null,
+            revertedFromReleaseId: release.revertedFromReleaseId ?? null, digest: release.manifestDigest,
+            isCurrent: release.releaseId === input.currentReleaseId,
+            pinnedUrl: state === 'purged' ? null : input.urls?.(input.artifactId, release.releaseId).pinnedUrl ?? null };
+    }));
+    const last = page.at(-1);
+    const position = (value) => ({ createdAt: value.createdAt, releaseId: value.releaseId });
+    return { artifactId: input.artifactId, currentReleaseId: input.currentReleaseId, versions,
+        nextCursor: last && available.length > page.length ? Buffer.from(JSON.stringify({ artifactId: input.artifactId,
+            storageScopeId: input.storageScopeId, snapshot: position(snapshot), after: position(last) })).toString('base64url') : null };
+}

package/docs/migration-l6.md

@@ -108,7 +108,14 @@ claim completion. Do not pass a raw pool to transaction-scoped deletion claims.
 ## Durable state and failures
 
 Stop old writers before enabling the new composition. Apply migrations
-`0001_artifacts.sql`, `0002_lifecycle.sql` and additive `0003_coordinator.sql`.
+`0001_artifacts.sql`, `0002_lifecycle.sql`, additive `0003_coordinator.sql`,
+`0004_terminal_controls.sql`, and `0005_metadata.sql` (metadata and release lineage).
+Preserve the existing host journal prefix, including activation assets, on upgrades.
+
+R2 bindings explicitly select `profileRevisionId`, `requireExpectedCurrentReleaseId`
+and `resultEnvelopeVersion`. The compatible p0b profile keeps full-bundle publication
+and root results. The CAS switchover can keep result version 1; activate part 1 only
+after qualification of result version 2. IMMO owns both switchovers and activation.
 Preserve historical rows and objects. Supply `legacyRecords`, using
 `createPostgresLegacyArtifactRecords(pool)` for PostgreSQL. An empty inventory
 reader is appropriate only for a verified fresh store.

package/migrations/0004_terminal_controls.sql

@@ -0,0 +1,47 @@
+-- Terminal deletion retains the identity and receipts; physical purge remains host policy.
+ALTER TABLE artifacts.artifacts ADD COLUMN IF NOT EXISTS terminal_deleted_at TIMESTAMPTZ;
+ALTER TABLE artifacts.artifacts ADD COLUMN IF NOT EXISTS updated_at TIMESTAMPTZ;
+-- Defaults affect new identities only; historical modification times remain unknown.
+ALTER TABLE artifacts.artifacts ALTER COLUMN updated_at SET DEFAULT now();
+
+CREATE OR REPLACE FUNCTION artifacts.reject_terminal_restore() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+  IF TG_OP = 'DELETE' THEN
+    IF OLD.terminal_deleted_at IS NOT NULL THEN RAISE EXCEPTION 'terminal artifact' USING ERRCODE = '23514'; END IF;
+    RETURN OLD;
+  END IF;
+  IF OLD.terminal_deleted_at IS NOT NULL AND
+    (NEW.terminal_deleted_at IS DISTINCT FROM OLD.terminal_deleted_at OR NEW.lifecycle_state NOT IN ('deleted', 'purged')
+      OR NEW.renewed_at IS DISTINCT FROM OLD.renewed_at) THEN
+    RAISE EXCEPTION 'terminal artifact' USING ERRCODE = '23514';
+  END IF;
+  RETURN NEW;
+END $$;
+DROP TRIGGER IF EXISTS terminal_restore_guard ON artifacts.artifacts;
+CREATE TRIGGER terminal_restore_guard BEFORE UPDATE ON artifacts.artifacts
+FOR EACH ROW EXECUTE FUNCTION artifacts.reject_terminal_restore();
+DROP TRIGGER IF EXISTS terminal_identity_guard ON artifacts.artifacts;
+CREATE TRIGGER terminal_identity_guard BEFORE DELETE ON artifacts.artifacts
+FOR EACH ROW EXECUTE FUNCTION artifacts.reject_terminal_restore();
+
+CREATE OR REPLACE FUNCTION artifacts.reject_terminal_publication() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+  PERFORM id FROM artifacts.artifacts WHERE id = NEW.artifact_id AND terminal_deleted_at IS NULL FOR KEY SHARE;
+  IF NOT FOUND THEN RAISE EXCEPTION 'terminal artifact' USING ERRCODE = '23514'; END IF;
+  RETURN NEW;
+END $$;
+DROP TRIGGER IF EXISTS terminal_release_guard ON artifacts.releases;
+CREATE TRIGGER terminal_release_guard BEFORE INSERT ON artifacts.releases
+FOR EACH ROW EXECUTE FUNCTION artifacts.reject_terminal_publication();
+
+CREATE OR REPLACE FUNCTION artifacts.record_publication_update() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+  UPDATE artifacts.artifacts SET updated_at = NEW.created_at WHERE id = NEW.artifact_id;
+  RETURN NEW;
+END $$;
+DROP TRIGGER IF EXISTS publication_updated_at ON artifacts.releases;
+CREATE TRIGGER publication_updated_at AFTER INSERT ON artifacts.releases
+FOR EACH ROW EXECUTE FUNCTION artifacts.record_publication_update();
+DROP TRIGGER IF EXISTS terminal_pointer_guard ON artifacts.artifact_current;
+CREATE TRIGGER terminal_pointer_guard BEFORE INSERT OR UPDATE ON artifacts.artifact_current
+FOR EACH ROW EXECUTE FUNCTION artifacts.reject_terminal_publication();

package/migrations/0005_metadata.sql

@@ -0,0 +1,14 @@
+-- Parity P0 — artifact display metadata (title/description/icon).
+--
+-- Additive upgrade after 0004_terminal_controls: no column is dropped or narrowed, existing
+-- rows keep working (default '{}' preserves "no metadata" semantics). The host
+-- applies this file through its existing migration journal.
+
+ALTER TABLE artifacts.artifacts
+  ADD COLUMN IF NOT EXISTS metadata JSONB NOT NULL DEFAULT '{}'::jsonb;
+
+-- Historical authors and lineage remain unknown; populate these on new commits only.
+ALTER TABLE artifacts.releases
+  ADD COLUMN IF NOT EXISTS author_principal_id TEXT,
+  ADD COLUMN IF NOT EXISTS parent_release_id UUID,
+  ADD COLUMN IF NOT EXISTS reverted_from_release_id UUID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentropic/artifacts",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "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",
@@ -103,6 +103,18 @@
       "types": "./dist/server/sources.d.ts",
       "import": "./dist/server/sources.js"
     },
+    "./server/source-read": {
+      "types": "./dist/server/source-read.d.ts",
+      "import": "./dist/server/source-read.js"
+    },
+    "./server/management": {
+      "types": "./dist/server/management.d.ts",
+      "import": "./dist/server/management.js"
+    },
+    "./adapters/postgres-management": {
+      "types": "./dist/adapters/postgres-management.d.ts",
+      "import": "./dist/adapters/postgres-management.js"
+    },
     "./server/fork": {
       "types": "./dist/server/fork.d.ts",
       "import": "./dist/server/fork.js"
@@ -181,6 +193,7 @@
     "docs/migration-l6.md",
     "examples/radar-commit-setup.ts",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "publishConfig": {
@@ -195,7 +208,7 @@
   },
   "peerDependencies": {
     "@aws-sdk/client-s3": "^3.980.0",
-    "@sentropic/mcp-platform": ">=0.3.0 <0.5.0",
+    "@sentropic/mcp-platform": ">=0.4.1 <0.5.0",
     "pg": "^8.12.0"
   },
   "peerDependenciesMeta": {