@sentropic/artifacts 0.1.4 → 0.2.0

package/dist/server/command-identity.js

@@ -0,0 +1,71 @@
+import { createHash } from 'node:crypto';
+import { isArtifactId } from '../contracts.js';
+import { assertCompiledArtifactsProfile, ArtifactProfileInputError } from '../profile/index.js';
+import { assertWellFormed, copyJson, freezeDeep, orderedDigest } from '../profile/json.js';
+export const COMMAND_CODEC_VERSION = 'artifacts-command/v1';
+/** Preserve Radar's durable bytes only within an explicitly qualified domain. */
+export function createRadarKeyDerivation(config) {
+    if (typeof config.storageScopeId !== 'string' || config.storageScopeId.trim() !== config.storageScopeId ||
+        !/^[A-Za-z0-9_-]+$/.test(config.storageScopeId) ||
+        !Array.isArray(config.actorIds) || !config.actorIds.length) {
+        throw new Error('unqualified Radar key domain');
+    }
+    const scope = config.storageScopeId;
+    const actors = new Set(config.actorIds);
+    for (const actor of actors) {
+        if (typeof actor !== 'string' || !actor.length)
+            throw new Error('invalid Radar actor domain');
+        assertWellFormed(actor);
+        for (const other of actors) {
+            if (other === actor || !other.startsWith(`${actor}|`))
+                continue;
+            const [operation, objectId] = other.slice(actor.length + 1).split('|');
+            if ((operation === 'ensure' && objectId === '') || (operation === 'publish' && isArtifactId(objectId))) {
+                throw new Error('ambiguous Radar actor domain');
+            }
+        }
+    }
+    return Object.freeze({
+        algorithm: 'radar-derive-idempotency-v1',
+        derive(input) {
+            const { storageScopeId, actorId, operation, objectId, callerKey } = input;
+            if (storageScopeId !== scope || !actors.has(actorId) ||
+                (operation !== 'ensure' && operation !== 'publish') ||
+                (operation === 'ensure' ? objectId !== '' : !isArtifactId(objectId)))
+                throw new ArtifactProfileInputError();
+            assertWellFormed(callerKey);
+            if (!callerKey.trim() || callerKey.length > 256)
+                throw new ArtifactProfileInputError();
+            return createHash('sha256').update([scope, actorId, operation, objectId, callerKey].join('|'), 'utf8')
+                .digest('hex');
+        },
+    });
+}
+export const commandDigest = orderedDigest;
+/** No caller hash, actor, scope, transport or audit identifier enters this API through arguments. */
+export function createArtifactCommand(profile, name, args, authority, derivation, envelopeKey) {
+    assertCompiledArtifactsProfile(profile);
+    if (derivation.algorithm !== profile.profile.rules.keyDerivationAlgorithm)
+        throw new Error('profile/derivation mismatch');
+    const normalized = profile.validate(name, args, envelopeKey);
+    if (name !== 'artifacts_ensure' && name !== 'artifacts_publish')
+        throw new ArtifactProfileInputError(true);
+    const operation = name === 'artifacts_ensure' ? 'ensure' : 'publish';
+    const { idempotencyKey, ...payload } = normalized;
+    const scopeBinding = authority.storageScopeId;
+    if (typeof scopeBinding !== 'string' || typeof authority.actorId !== 'string')
+        throw new ArtifactProfileInputError();
+    assertWellFormed(scopeBinding);
+    assertWellFormed(authority.actorId);
+    if (!scopeBinding || !authority.actorId)
+        throw new ArtifactProfileInputError();
+    const provenance = { kind: 'inline-original' };
+    const effective = copyJson({ operation, scopeBinding, payload: { ...payload, provenance } });
+    const internalKey = derivation.derive({ storageScopeId: scopeBinding, actorId: authority.actorId, operation,
+        objectId: operation === 'publish' ? normalized.artifactId : '',
+        callerKey: idempotencyKey });
+    if (!/^[0-9a-f]{64}$/.test(internalKey) || !derivation.algorithm)
+        throw new Error('invalid key derivation binding');
+    return freezeDeep({ ...effective, provenance, identity: { internalKey,
+            commandHash: commandDigest(effective), codecVersion: COMMAND_CODEC_VERSION } });
+}

package/dist/server/commit/brands.d.ts

@@ -0,0 +1,7 @@
+import type { ArtifactAuthorizationFence, ArtifactCommitTransaction } from '#artifacts-frozen-commit';
+type CommitFenceBrand = Extract<keyof ArtifactAuthorizationFence, symbol>;
+type CommitTransactionBrand = Extract<keyof ArtifactCommitTransaction, symbol>;
+/** Runtime credentials implement the frozen brands without changing the freeze. */
+export declare const commitFenceBrand: CommitFenceBrand;
+export declare const commitTransactionBrand: CommitTransactionBrand;
+export {};

package/dist/server/commit/brands.js

@@ -0,0 +1,3 @@
+/** Runtime credentials implement the frozen brands without changing the freeze. */
+export const commitFenceBrand = Symbol('artifact-authorization-fence');
+export const commitTransactionBrand = Symbol('artifact-commit-transaction');

package/dist/server/commit/coordinator.d.ts

@@ -0,0 +1,2 @@
+import { type ArtifactCommitCoordinator, type CommitCoordinatorOptions } from './types.js';
+export declare function createArtifactCommitCoordinator(options: CommitCoordinatorOptions): ArtifactCommitCoordinator;