@sentropic/artifacts 0.0.0-stage → 0.1.1

package/dist/mcp.js

@@ -0,0 +1,293 @@
+import { computeManifestDigest } from '@sentropic/mcp-platform/tool-configuration';
+export const ARTIFACTS_PROVIDER_ID = 'sentropic.artifacts';
+export const ARTIFACTS_APP_ID = 'sentropic-artifacts';
+export const ARTIFACTS_PROVIDER_VERSION = '0.1.0';
+export const ARTIFACTS_TOOL_NAMES = [
+    'artifacts_get_template', 'artifacts_get_api_guide', 'artifacts_ensure',
+    'artifacts_publish', 'artifacts_create_upload', 'artifacts_commit_upload',
+    'artifacts_list', 'artifacts_get', 'artifacts_get_source', 'artifacts_fork',
+    'artifacts_set_access', 'artifacts_promote', 'artifacts_renew',
+    'artifacts_delete', 'artifacts_restore',
+];
+const str = { type: 'string', minLength: 1 };
+const int = (minimum, maximum) => ({
+    type: 'integer', minimum, ...(maximum === undefined ? {} : { maximum }),
+});
+const obj = (properties, required = []) => ({
+    type: 'object', properties, required, additionalProperties: false,
+});
+const record = {
+    type: 'object',
+    additionalProperties: { type: ['string', 'number', 'boolean', 'null'] },
+};
+const fileBytes = { type: 'array', items: int(0, 255) };
+const fileEntry = obj({ path: str, mimeType: str, bytes: fileBytes }, ['path', 'mimeType', 'bytes']);
+const sourceRef = obj({
+    kind: { type: 'string', enum: ['inline-original', 'base-commit', 'recipe'] },
+    commit: { type: 'string' },
+    steps: { type: 'array', items: { type: 'string' } },
+}, ['kind']);
+const idOnly = obj({ artifactId: str }, ['artifactId']);
+export const ARTIFACTS_TOOL_SPECS = [
+    { name: 'artifacts_get_template', description: 'Get an approved template kit (sources + build recipe).', inputSchema: obj({ templateId: str }, ['templateId']), mutability: 'read-only' },
+    { name: 'artifacts_get_api_guide', description: 'Get the versioned artifacts API guide.', inputSchema: obj({ version: str }), mutability: 'read-only' },
+    { name: 'artifacts_ensure', description: 'Resolve or create the private artifact view for a binding.', inputSchema: obj({ bindingName: str, storageScopeId: str, idempotencyKey: str, paramsHash: str, parameters: record }, ['bindingName', 'idempotencyKey']), mutability: 'state-transition', idempotent: true },
+    { name: 'artifacts_publish', description: 'Publish inline files as a new release.', inputSchema: obj({ artifactId: str, files: { type: 'array', minItems: 1, items: fileEntry }, profile: record, source: sourceRef, idempotencyKey: str, paramsHash: str }, ['artifactId', 'files']), mutability: 'append', idempotent: true },
+    { name: 'artifacts_create_upload', description: 'Open a bounded upload session for large bytes.', inputSchema: obj({ artifactId: str, mimeType: str, maxSize: int(1) }, ['artifactId', 'mimeType']), mutability: 'state-transition' },
+    { name: 'artifacts_commit_upload', description: 'Verify staged bytes and publish them as a release.', inputSchema: obj({ artifactId: str, uploadId: str, path: str, mimeType: str, digest: str, size: int(0), profile: record, idempotencyKey: str, paramsHash: str }, ['artifactId', 'uploadId', 'path', 'mimeType', 'digest', 'size']), mutability: 'append', idempotent: true },
+    { name: 'artifacts_list', description: 'List artifacts visible to the caller (ACL before pagination).', inputSchema: obj({ limit: int(1, 100), offset: int(0) }), mutability: 'read-only' },
+    { name: 'artifacts_get', description: 'Get artifact metadata (grants visible to the owner only).', inputSchema: idOnly, mutability: 'read-only' },
+    { name: 'artifacts_get_source', description: 'Export the attached source reference (separate right).', inputSchema: idOnly, mutability: 'read-only' },
+    { name: 'artifacts_fork', description: 'Fork privately under a fresh identity (no ACL copied).', inputSchema: idOnly, mutability: 'state-transition' },
+    { name: 'artifacts_set_access', description: 'Grant or revoke read/source access, or toggle public mode.', inputSchema: obj({ artifactId: str, action: { type: 'string', enum: ['grant', 'revoke', 'set-public'] }, principalId: str, grant: { type: 'string', enum: ['read', 'source'] }, isPublic: { type: 'boolean' } }, ['artifactId', 'action']), mutability: 'patch', confirm: true },
+    { name: 'artifacts_promote', description: 'Select a release explicitly (expected-current CAS).', inputSchema: obj({ artifactId: str, releaseId: str, expectedCurrent: str }, ['artifactId', 'releaseId', 'expectedCurrent']), mutability: 'patch' },
+    { name: 'artifacts_renew', description: 'Renew the artifact retention timestamp.', inputSchema: idOnly, mutability: 'patch' },
+    { name: 'artifacts_delete', description: 'Withdraw into pending deletion (undo via artifacts_restore).', inputSchema: idOnly, mutability: 'delete', confirm: true },
+    { name: 'artifacts_restore', description: 'Cancel a pending deletion or withdrawal before purge.', inputSchema: idOnly, mutability: 'state-transition' },
+];
+/** Kernel provider parameter schema (typed non-secret host settings). */
+export const ARTIFACTS_PARAMETER_SCHEMA = {
+    properties: {
+        defaultStorageScopeId: { type: 'string', minLength: 1, description: 'Fallback storage scope for artifacts_ensure.' },
+        uploadBudgetBytes: { type: 'integer', minimum: 1, description: 'Declared bounded-upload budget.' },
+    },
+    required: [],
+};
+/** Build the sentropic.artifacts manifest (host scope bound pre-freeze). */
+export function createArtifactsManifest(options = {}) {
+    const scopes = options.invocationScope === undefined ? [] : [options.invocationScope];
+    const tools = ARTIFACTS_TOOL_SPECS.map((spec) => ({
+        kind: 'tool',
+        name: spec.name,
+        description: spec.description,
+        requiredScopes: [...scopes],
+        requiredClaims: [],
+        inputSchema: spec.inputSchema,
+        outputSchema: { type: 'object' },
+        redactionClass: 'low',
+        mutability: spec.mutability,
+        mutatesExternalSystem: spec.mutability !== 'read-only',
+        idempotency: spec.idempotent === true
+            ? { required: true, scope: 'principal' }
+            : { required: false },
+        gates: {
+            requiresElicitation: false,
+            requiresHumanConfirmation: spec.confirm === true,
+            requiresPrincipalGate: false,
+        },
+    }));
+    return {
+        appId: ARTIFACTS_APP_ID,
+        providerId: ARTIFACTS_PROVIDER_ID,
+        version: ARTIFACTS_PROVIDER_VERSION,
+        displayName: options.displayName ?? 'Sentropic Artifacts',
+        resources: [],
+        tools,
+        prompts: [],
+        authz: { requiredClaims: [], scopes: [...scopes], tenantResolution: 'custom-resolver' },
+        audit: { eventKinds: ['invoke'] },
+        durability: {},
+    };
+}
+function needString(args, name) {
+    const value = args[name];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`invalid request: missing ${name}`);
+    }
+    return value;
+}
+function optString(args, name) {
+    const value = args[name];
+    return typeof value === 'string' && value.length !== 0 ? value : undefined;
+}
+/** Create the 15-tool executor over any conforming artifacts HTTP app. */
+export function createArtifactsToolExecutor(deps) {
+    const call = (actorId, method, path, body) => deps.app.handle({ method, path, actorId, body });
+    function setAccess(actorId, args) {
+        const artifactId = needString(args, 'artifactId');
+        const action = needString(args, 'action');
+        if (action === 'grant') {
+            const grant = needString(args, 'grant');
+            if (grant !== 'read' && grant !== 'source') {
+                throw new Error('invalid request: grant must be read or source');
+            }
+            return call(actorId, 'POST', '/access/grant', {
+                artifactId, principalId: needString(args, 'principalId'), grant,
+            });
+        }
+        if (action === 'revoke') {
+            return call(actorId, 'POST', '/access/revoke', {
+                artifactId, principalId: needString(args, 'principalId'),
+            });
+        }
+        if (action === 'set-public') {
+            if (typeof args['isPublic'] !== 'boolean') {
+                throw new Error('invalid request: isPublic must be a boolean');
+            }
+            return call(actorId, 'POST', '/access/public', { artifactId, isPublic: args['isPublic'] });
+        }
+        throw new Error(`invalid request: unknown set-access action ${action}`);
+    }
+    return {
+        async invoke(input) {
+            const { actorId, args } = input;
+            switch (input.tool) {
+                case 'artifacts_get_template':
+                    return call(actorId, 'GET', `/templates/${needString(args, 'templateId')}`);
+                case 'artifacts_get_api_guide': {
+                    const version = optString(args, 'version');
+                    return call(actorId, 'GET', version === undefined ? '/api-guide' : `/api-guide/${version}`);
+                }
+                case 'artifacts_ensure':
+                    return call(actorId, 'POST', '/ensure', {
+                        bindingName: needString(args, 'bindingName'),
+                        storageScopeId: optString(args, 'storageScopeId') ?? deps.defaultStorageScopeId
+                            ?? needString(args, 'storageScopeId'),
+                        idempotencyKey: needString(args, 'idempotencyKey'),
+                        paramsHash: optString(args, 'paramsHash') ?? '',
+                        parameters: args['parameters'] ?? {},
+                    });
+                case 'artifacts_publish':
+                    return call(actorId, 'POST', '/publish', {
+                        artifactId: needString(args, 'artifactId'),
+                        files: args['files'],
+                        profile: args['profile'] ?? {},
+                        source: args['source'],
+                        idempotencyKey: optString(args, 'idempotencyKey'),
+                        paramsHash: optString(args, 'paramsHash'),
+                    });
+                case 'artifacts_create_upload':
+                    return call(actorId, 'POST', '/uploads', {
+                        artifactId: needString(args, 'artifactId'),
+                        mimeType: needString(args, 'mimeType'),
+                        maxSize: args['maxSize'],
+                    });
+                case 'artifacts_commit_upload':
+                    return call(actorId, 'POST', '/uploads/commit', {
+                        artifactId: needString(args, 'artifactId'),
+                        uploadId: needString(args, 'uploadId'),
+                        path: needString(args, 'path'),
+                        mimeType: needString(args, 'mimeType'),
+                        digest: needString(args, 'digest'),
+                        size: args['size'],
+                        profile: args['profile'] ?? {},
+                        idempotencyKey: optString(args, 'idempotencyKey'),
+                        paramsHash: optString(args, 'paramsHash'),
+                    });
+                case 'artifacts_list':
+                    return call(actorId, 'POST', '/list', { limit: args['limit'], offset: args['offset'] });
+                case 'artifacts_get':
+                    return call(actorId, 'GET', `/meta/${needString(args, 'artifactId')}`);
+                case 'artifacts_get_source':
+                    return call(actorId, 'GET', `/source/${needString(args, 'artifactId')}`);
+                case 'artifacts_fork':
+                    return call(actorId, 'POST', '/fork', { artifactId: needString(args, 'artifactId') });
+                case 'artifacts_set_access':
+                    return setAccess(actorId, args);
+                case 'artifacts_promote':
+                    return call(actorId, 'POST', '/promote', {
+                        artifactId: needString(args, 'artifactId'),
+                        releaseId: needString(args, 'releaseId'),
+                        expectedCurrent: needString(args, 'expectedCurrent'),
+                    });
+                case 'artifacts_renew':
+                    return call(actorId, 'POST', '/renew', { artifactId: needString(args, 'artifactId') });
+                case 'artifacts_delete':
+                    return call(actorId, 'POST', '/delete', { artifactId: needString(args, 'artifactId') });
+                case 'artifacts_restore':
+                    return call(actorId, 'POST', '/restore', { artifactId: needString(args, 'artifactId') });
+                default:
+                    throw new Error(`unknown artifacts tool: ${input.tool}`);
+            }
+        },
+    };
+}
+function errorCodeOf(body) {
+    if (typeof body === 'object' && body !== null) {
+        const code = body['error'];
+        if (typeof code === 'string' && code.length !== 0)
+            return code;
+    }
+    return 'internal_error';
+}
+/** Create the platform adapter driving the 15 tools over the shared app. */
+export function createArtifactsAdapter(options) {
+    const manifest = createArtifactsManifest(options);
+    const executor = createArtifactsToolExecutor({
+        app: options.app,
+        defaultStorageScopeId: options.defaultStorageScopeId,
+    });
+    return {
+        appId: ARTIFACTS_APP_ID,
+        connectorId: ARTIFACTS_PROVIDER_ID,
+        manifest,
+        resolveTenant: (input) => Promise.resolve({
+            principalRef: input.principalSub,
+            tenantRef: input.tenantRef,
+            connectorInstanceId: input.connectorInstanceId,
+            ...(input.workspaceRef === undefined ? {} : { workspaceRef: input.workspaceRef }),
+        }),
+        listCapabilities: () => Promise.resolve([...manifest.tools]),
+        async invokeTool(req) {
+            const auditId = req.ctx.auditId;
+            try {
+                const args = typeof req.input === 'object' && req.input !== null && !Array.isArray(req.input)
+                    ? req.input
+                    : {};
+                const res = await executor.invoke({
+                    tool: req.capabilityRef,
+                    actorId: req.ctx.principal.sub,
+                    args,
+                });
+                if (res.status >= 200 && res.status < 300) {
+                    return { ok: true, output: res.body, auditId, redactionClass: 'low' };
+                }
+                const code = errorCodeOf(res.body);
+                return {
+                    ok: false, auditId, redactionClass: 'low',
+                    error: { code, message: code, retriable: res.status >= 500 },
+                };
+            }
+            catch {
+                return {
+                    ok: false, auditId, redactionClass: 'low',
+                    error: { code: 'invalid_request', message: 'invalid_request', retriable: false },
+                };
+            }
+        },
+        readResource: (req) => Promise.resolve({
+            ok: false,
+            auditId: req.ctx.auditId,
+            redactionClass: 'low',
+            error: { code: 'not_found', message: 'not_found', retriable: false },
+        }),
+        validateSecrets: () => Promise.resolve([]),
+    };
+}
+const EMPTY_TOOL_CONFIG = { type: 'object', properties: {}, additionalProperties: false };
+/** Build the kernel registry definition for sentropic.artifacts (§3). */
+export function createArtifactsRegistryDefinition(options) {
+    const adapter = createArtifactsAdapter(options);
+    const manifest = adapter.manifest;
+    const handlers = {};
+    const toolValues = {};
+    for (const spec of ARTIFACTS_TOOL_SPECS) {
+        const handlerId = `${spec.name}-handler`;
+        handlers[handlerId] = { handlerId, capabilityRef: spec.name, configSchema: EMPTY_TOOL_CONFIG };
+        toolValues[spec.name] = { handlerId, values: {} };
+    }
+    return {
+        manifest,
+        adapter,
+        parameterSchema: ARTIFACTS_PARAMETER_SCHEMA,
+        handlers,
+        requiredPorts: [],
+        provenance: {
+            approvalRef: options.approvalRef ?? 'artifacts-local-1',
+            revision: options.revision ?? 'rev-1',
+            manifestDigest: computeManifestDigest(manifest),
+            reviewedBy: options.reviewedBy ?? ['host-owner'],
+        },
+        toolValues,
+    };
+}

package/dist/parameters.d.ts

@@ -0,0 +1,29 @@
+/**
+ * L-5a — provider parameter schema and validation (spec-v8 §9).
+ *
+ * Generic, non-secret provider settings: each declaration names a key, its
+ * type and whether it is required or defaulted. Validation applies defaults
+ * and rejects unknown keys, wrong types, missing required values and
+ * secret-looking keys fail-closed — provider parameters are never a secret
+ * store. Schemas are independent values; no global bag is shared.
+ */
+import type { JsonValue } from './contracts.js';
+export type ParameterType = 'string' | 'number' | 'boolean' | 'enum';
+export interface ParameterDeclaration {
+    key: string;
+    type: ParameterType;
+    required?: boolean;
+    default?: JsonValue;
+    values?: string[];
+    description?: string;
+}
+export interface ParameterSchema {
+    declarations: ParameterDeclaration[];
+}
+/** Declare a parameter schema; rejects duplicates and empty declarations. */
+export declare function defineParameters(declarations: ParameterDeclaration[]): ParameterSchema;
+/**
+ * Validate values against a schema: apply defaults, reject unknown keys,
+ * wrong types, missing required values and secret-looking keys.
+ */
+export declare function validateParameters(schema: ParameterSchema, values: Record<string, JsonValue | undefined>): Record<string, JsonValue>;

package/dist/parameters.js

@@ -0,0 +1,65 @@
+/** Keys that look like secrets are refused anywhere in validated values. */
+const SECRET_KEY_PATTERN = /(secret|token|password|private[_-]?key|api[_-]?key)/i;
+/** Declare a parameter schema; rejects duplicates and empty declarations. */
+export function defineParameters(declarations) {
+    const seen = new Set();
+    for (const decl of declarations) {
+        if (typeof decl.key !== 'string' || decl.key.length === 0) {
+            throw new Error('invalid parameter declaration: empty key');
+        }
+        if (seen.has(decl.key)) {
+            throw new Error(`invalid parameter declaration: duplicate key ${decl.key}`);
+        }
+        seen.add(decl.key);
+        if (decl.type === 'enum' && (!Array.isArray(decl.values) || decl.values.length === 0)) {
+            throw new Error(`invalid parameter declaration: enum ${decl.key} needs values`);
+        }
+    }
+    return { declarations: [...declarations] };
+}
+function checkType(decl, value) {
+    switch (decl.type) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number';
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'enum':
+            return typeof value === 'string' && (decl.values ?? []).includes(value);
+    }
+}
+/**
+ * Validate values against a schema: apply defaults, reject unknown keys,
+ * wrong types, missing required values and secret-looking keys.
+ */
+export function validateParameters(schema, values) {
+    for (const key of Object.keys(values)) {
+        if (SECRET_KEY_PATTERN.test(key)) {
+            throw new Error(`invalid parameters: secret-looking key refused: ${key}`);
+        }
+    }
+    const known = new Map(schema.declarations.map((d) => [d.key, d]));
+    for (const key of Object.keys(values)) {
+        if (values[key] !== undefined && !known.has(key)) {
+            throw new Error(`invalid parameters: unknown parameter ${key}`);
+        }
+    }
+    const out = {};
+    for (const decl of schema.declarations) {
+        const value = values[decl.key];
+        if (value === undefined) {
+            if (decl.required) {
+                throw new Error(`invalid parameters: missing required parameter ${decl.key}`);
+            }
+            if (decl.default !== undefined)
+                out[decl.key] = decl.default;
+            continue;
+        }
+        if (!checkType(decl, value)) {
+            throw new Error(`invalid parameters: wrong type for ${decl.key}`);
+        }
+        out[decl.key] = value;
+    }
+    return out;
+}

package/dist/provider-definition.d.ts

@@ -0,0 +1,36 @@
+/**
+ * L-5a — generic provider definitions (spec-v8 §9).
+ *
+ * A provider definition binds a provider ID to its capabilities and its
+ * parameter schema. Provider-internal keys are (providerId, capabilityName);
+ * the external map is exact publicName → that pair. Duplicate public names
+ * are rejected at definition time; cross-provider collisions are rejected by
+ * `assertNoPublicNameCollisions` before activation. No sanitizing,
+ * suffixing, auto-prefixing or silent first/last keep.
+ */
+import type { ParameterSchema } from './parameters.js';
+export type CapabilityKind = 'tool' | 'resource' | 'prompt';
+export interface CapabilityDefinition {
+    kind: CapabilityKind;
+    /** Internal capability name, unique within the provider. */
+    name: string;
+    /** Exact external name; must be unique across all activated providers. */
+    publicName: string;
+    description?: string;
+}
+export interface ProviderDefinition {
+    providerId: string;
+    version: string;
+    parameters: ParameterSchema;
+    capabilities: CapabilityDefinition[];
+}
+export interface ResolvedCapability {
+    providerId: string;
+    capabilityName: string;
+}
+/** Define a provider; rejects empty IDs and duplicate public/capability names. */
+export declare function defineProvider(def: ProviderDefinition): ProviderDefinition;
+/** Exact publicName → (providerId, capabilityName) map for one provider. */
+export declare function publicNameMap(def: ProviderDefinition): Map<string, ResolvedCapability>;
+/** Reject tool-name collisions across providers before activation. */
+export declare function assertNoPublicNameCollisions(defs: ProviderDefinition[]): void;

package/dist/provider-definition.js

@@ -0,0 +1,45 @@
+/** Define a provider; rejects empty IDs and duplicate public/capability names. */
+export function defineProvider(def) {
+    if (typeof def.providerId !== 'string' || def.providerId.length === 0) {
+        throw new Error('invalid provider definition: empty providerId');
+    }
+    const publicNames = new Set();
+    const names = new Set();
+    for (const cap of def.capabilities) {
+        if (names.has(cap.name)) {
+            throw new Error(`invalid provider definition: duplicate capability name ${cap.name}`);
+        }
+        names.add(cap.name);
+        if (publicNames.has(cap.publicName)) {
+            throw new Error(`invalid provider definition: duplicate publicName ${cap.publicName}`);
+        }
+        publicNames.add(cap.publicName);
+    }
+    return {
+        providerId: def.providerId,
+        version: def.version,
+        parameters: def.parameters,
+        capabilities: [...def.capabilities],
+    };
+}
+/** Exact publicName → (providerId, capabilityName) map for one provider. */
+export function publicNameMap(def) {
+    const map = new Map();
+    for (const cap of def.capabilities) {
+        map.set(cap.publicName, { providerId: def.providerId, capabilityName: cap.name });
+    }
+    return map;
+}
+/** Reject tool-name collisions across providers before activation. */
+export function assertNoPublicNameCollisions(defs) {
+    const seen = new Map();
+    for (const def of defs) {
+        for (const cap of def.capabilities) {
+            const owner = seen.get(cap.publicName);
+            if (owner !== undefined && owner !== def.providerId) {
+                throw new Error(`publicName collision: ${cap.publicName} claimed by ${owner} and ${def.providerId}`);
+            }
+            seen.set(cap.publicName, def.providerId);
+        }
+    }
+}

package/dist/server/access.d.ts

@@ -0,0 +1,39 @@
+/**
+ * L-5c — access control (spec-v8 §9 5c).
+ *
+ * Pure evaluation over an artifact ACL: the owner reads, exports source and
+ * manages grants; explicit grants give read or source (source implies read,
+ * read never implies source); a public flag opens reads to approved accounts
+ * only — never anonymous, never source. Withdrawal suspends reader grants
+ * (kept for audit, inactive) while the owner keeps access. Grant management
+ * is owner-only; duplicate grants are refused. Identity approval comes from
+ * the host via an injected predicate (memory double in tests).
+ */
+export type AccessGrant = 'read' | 'source';
+export type AccessAction = 'read' | 'source';
+export interface GrantRecord {
+    principalId: string;
+    grant: AccessGrant;
+}
+export interface ArtifactAcl {
+    ownerId: string;
+    /** Physical scope of the artifact (set at creation; read by publish). */
+    storageScopeId?: string;
+    isPublic: boolean;
+    withdrawn: boolean;
+    grants: GrantRecord[];
+}
+export interface AclStore {
+    getArtifactAcl(artifactId: string): Promise<ArtifactAcl | undefined>;
+    putArtifactAcl(artifactId: string, acl: ArtifactAcl): Promise<void>;
+    /** All known artifact IDs (stable creation order); filter by ACL first. */
+    listArtifactIds(): Promise<string[]>;
+}
+/** In-memory AclStore double for unit tests. */
+export declare function createMemoryAclStore(): AclStore;
+/** True when the actor may perform the action (deny by default). */
+export declare function evaluateAccess(acl: ArtifactAcl, actorId: string, action: AccessAction, isApproved?: (principalId: string) => boolean): boolean;
+/** Owner-only: add a grant (duplicates refused). */
+export declare function grantAccess(acl: ArtifactAcl, actorId: string, grant: GrantRecord): ArtifactAcl;
+/** Owner-only: remove a grant (kept for audit by the caller if needed). */
+export declare function revokeAccess(acl: ArtifactAcl, actorId: string, principalId: string): ArtifactAcl;

package/dist/server/access.js

@@ -0,0 +1,53 @@
+/** In-memory AclStore double for unit tests. */
+export function createMemoryAclStore() {
+    const acls = new Map();
+    return {
+        getArtifactAcl(artifactId) {
+            const acl = acls.get(artifactId);
+            return Promise.resolve(acl === undefined
+                ? undefined
+                : { ...acl, grants: acl.grants.map((g) => ({ ...g })) });
+        },
+        putArtifactAcl(artifactId, acl) {
+            acls.set(artifactId, { ...acl, grants: acl.grants.map((g) => ({ ...g })) });
+            return Promise.resolve();
+        },
+        listArtifactIds() {
+            return Promise.resolve([...acls.keys()]);
+        },
+    };
+}
+/** True when the actor may perform the action (deny by default). */
+export function evaluateAccess(acl, actorId, action, isApproved = () => false) {
+    if (actorId.length === 0)
+        return false;
+    if (actorId === acl.ownerId)
+        return true;
+    if (acl.withdrawn)
+        return false;
+    const grant = acl.grants.find((g) => g.principalId === actorId)?.grant;
+    if (grant === 'source')
+        return true;
+    if (grant === 'read' && action === 'read')
+        return true;
+    if (action === 'read' && acl.isPublic && isApproved(actorId))
+        return true;
+    return false;
+}
+/** Owner-only: add a grant (duplicates refused). */
+export function grantAccess(acl, actorId, grant) {
+    if (actorId !== acl.ownerId)
+        throw new Error('access denied: only the owner manages grants');
+    if (grant.principalId.length === 0)
+        throw new Error('invalid grant: empty principal');
+    if (acl.grants.some((g) => g.principalId === grant.principalId)) {
+        throw new Error(`duplicate grant for ${grant.principalId}`);
+    }
+    return { ...acl, grants: [...acl.grants, grant] };
+}
+/** Owner-only: remove a grant (kept for audit by the caller if needed). */
+export function revokeAccess(acl, actorId, principalId) {
+    if (actorId !== acl.ownerId)
+        throw new Error('access denied: only the owner manages grants');
+    return { ...acl, grants: acl.grants.filter((g) => g.principalId !== principalId) };
+}

package/dist/server/authorization.d.ts

@@ -0,0 +1,17 @@
+/**
+ * L-5a — object-level authorization (spec-v8 §9).
+ *
+ * Private artifacts are owner-only: the acting user must equal the recorded
+ * artifact owner for both read and mutate. Anything else — forged owner,
+ * anonymous actor, empty owner — is denied fail-closed. There are no sharing
+ * grants in this lot (sharing arrives with L-5c access.ts), so the action
+ * set is closed: unknown actions are refused rather than defaulted.
+ */
+export type ArtifactAction = 'read' | 'mutate';
+export interface AccessRequest {
+    actorUserId: string;
+    artifactOwnerId: string;
+    action: string;
+}
+/** Assert owner-only access; throws fail-closed on any mismatch. */
+export declare function assertArtifactAccess(request: AccessRequest): void;

package/dist/server/authorization.js

@@ -0,0 +1,12 @@
+/** Assert owner-only access; throws fail-closed on any mismatch. */
+export function assertArtifactAccess(request) {
+    if (request.action !== 'read' && request.action !== 'mutate') {
+        throw new Error(`access denied: unknown action ${request.action}`);
+    }
+    if (request.actorUserId.length === 0 || request.artifactOwnerId.length === 0) {
+        throw new Error('access denied: anonymous actor or empty owner');
+    }
+    if (request.actorUserId !== request.artifactOwnerId) {
+        throw new Error('access denied: not the artifact owner');
+    }
+}

package/dist/server/bindings.d.ts

@@ -0,0 +1,34 @@
+/**
+ * L-5a — owner-scoped stable bindings (spec-v8 §9).
+ *
+ * A logical binding (owner + name) resolves to one server-allocated UUID no
+ * matter which client ensures it first; both fresh clients converge on the
+ * same identity. Another owner resolves nothing: lookup is always qualified
+ * by ownerId, so binding names and digests cannot be guessed across owners.
+ * A conflicting storage scope on an existing binding fails closed (mappings
+ * stay server-verified; ambiguous mappings never silently win). Concurrent
+ * ensures serialize on a per-key singleflight so exactly one creation wins.
+ * Persistence goes through the injected KvPort only (ports.ts).
+ */
+import { type KvPort, type UuidPort } from './ports.js';
+export interface BindingInput {
+    ownerId: string;
+    storageScopeId: string;
+    bindingName: string;
+}
+export interface BindingLookup {
+    ownerId: string;
+    bindingName: string;
+}
+export interface BindingResult {
+    artifactId: string;
+    created: boolean;
+}
+export interface BindingService {
+    ensure(input: BindingInput): Promise<BindingResult>;
+    find(lookup: BindingLookup): Promise<string | undefined>;
+}
+/** Memory-backed KvPort for unit tests (re-exported from the ports module). */
+export declare function createMemoryBindingKv(): KvPort;
+/** Create a binding service over an injected KvPort (no driver imports). */
+export declare function createBindingService(kv: KvPort, uuid?: UuidPort): BindingService;