@byok-sdk/core 0.2.0 → 0.4.0

package/dist/attestation.d.ts

@@ -38,6 +38,13 @@ export declare const DEVICE_PROOF_VERSION = 1;
 /** Signature algorithms this envelope version admits. */
 export declare const DEVICE_PROOF_ALGORITHMS: readonly ['ed25519'];
 export type DeviceProofAlgorithm = (typeof DEVICE_PROOF_ALGORITHMS)[number];
+/**
+ * HTTP header carrying the base64url device-proof envelope on a truth-route
+ * request (§12.6.3). Both the daemon that mints the proof and the host that
+ * decodes it must name the exact same header, so it is a single wire constant
+ * here rather than a string re-spelled on each side.
+ */
+export declare const DEVICE_PROOF_HEADER = "x-byok-device-proof";
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | readonly JsonValue[] | {
     readonly [key: string]: JsonValue;

package/dist/blob.d.ts

@@ -17,11 +17,52 @@ export type ContentHash = string & {
 export declare function contentHash(value: string): ContentHash;
 /** Non-throwing form of {@link contentHash}. */
 export declare function isContentHash(value: unknown): value is ContentHash;
+/**
+ * What a deployment-level key namespace may look like: slash-joined segments of
+ * lowercase alphanumerics, `.`, `_`, and `-`, each starting with an
+ * alphanumeric. No leading or trailing slash, and therefore no empty segment.
+ *
+ * Narrow on purpose, and narrower than S3 keys allow. A prefix is spliced into
+ * every key this SDK ever writes, so the only prefixes worth accepting are the
+ * ones that reach the object store spelled exactly as configured: anything
+ * requiring percent-encoding would give the deployment's objects two names, and
+ * anything with an empty segment would make `a//b` and `a/b` the same key at
+ * rest but different strings in config. Case is folded out for the same reason
+ * {@link contentHash} refuses uppercase hex — one address, one spelling.
+ */
+export declare const OBJECT_KEY_PREFIX_PATTERN: RegExp;
+/** A validated deployment key namespace. Branded, so only the mint point below can produce one. */
+export type ObjectKeyPrefix = string & {
+    readonly __byokObjectKeyPrefix: unique symbol;
+};
+/**
+ * The single mint point for {@link ObjectKeyPrefix}.
+ *
+ * There is no "empty means no prefix" spelling here: a composition that has no
+ * prefix omits the option, and one that passes `''` has misconfigured something
+ * (an unset environment variable is the usual way). Accepting it silently would
+ * make the two indistinguishable at exactly the moment the difference decides
+ * where a deployment's objects live.
+ *
+ * @throws {ByokCoreError} code `object_key_prefix_invalid`.
+ */
+export declare function objectKeyPrefix(value: string): ObjectKeyPrefix;
 /**
  * Tenant-scoped object key, e.g.
  * `tenants/<tenantId>/objects/sha256/<hex>` (§12.7.4).
+ *
+ * `prefix` namespaces the whole layout — `<prefix>/tenants/...` — so one bucket
+ * can hold several deployments without either of them owning the bucket root.
+ * Omitting it produces the unprefixed key verbatim, which is what makes the
+ * option safe to add: every object already at rest was written without one.
+ *
+ * The prefix is an IMMUTABLE property of a deployment. It is spliced in here
+ * and nowhere else, and nothing reads a key back under a second layout: change
+ * a live deployment's prefix and its existing objects become unaddressable.
+ * See `R2BlobStoreOptions.keyPrefix` in `@byok-sdk/cloud-dataplane` for the full
+ * operational contract.
  */
-export declare function tenantObjectKey(tenant: TenantId, hash: ContentHash): string;
+export declare function tenantObjectKey(tenant: TenantId, hash: ContentHash, prefix?: ObjectKeyPrefix): string;
 /**
  * Object manifest lifecycle (§12.7.8).
  *

package/dist/device-assertion.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Device assertion envelope, canonical signing bytes, and verifier
+ * (plan `device-assertion-broker`, P3 ①-⑤).
+ *
+ * A device assertion is a short-lived, audience-scoped statement a *paired
+ * device* makes about itself — "this device, paired to this product against
+ * this server, wants to talk to `<audience>` for the next two minutes" — signed
+ * with the same Ed25519 device identity key `attestation.ts`'s device proof
+ * uses. A sibling CLI installed alongside the daemon presents one to the host's
+ * cloud, which exchanges it for a product session. It is NOT a request-bound
+ * proof (`attestation.ts`) and the two must never be interchangeable; see the
+ * domain prefix below.
+ *
+ * Four decisions this file encodes, none of them re-litigable here:
+ *
+ * 1. **A custom JSON signing envelope, not JWS.** The domain prefix has to be
+ *    *inside* the signed bytes. JWS puts its type tag in a header that no
+ *    verifier is required to check, which is a fail-open shape: a token minted
+ *    for one purpose verifies for another as long as the key matches. So this
+ *    clones the mechanism `attestation.ts` already froze — RFC 8785-subset
+ *    canonicalization (`canonicalizeJson`, imported, never re-implemented) plus
+ *    a golden fixture pinning the exact bytes.
+ * 2. **What the claims deliberately do NOT carry.** No `devicePublicKey`: a
+ *    verifier must resolve the key from its own device directory by `deviceId`,
+ *    or the envelope becomes self-authenticating. No caller identity: every
+ *    process under the same UID can reach the control socket, so a "who asked"
+ *    field would be synthesized authority, not evidence. No `keyId`: there is
+ *    no key-rotation story for this envelope yet, and a field nothing populates
+ *    honestly is a structure that invites a verifier to trust it.
+ * 3. **`audience` is a single string, never an array.** A multi-audience token
+ *    forces every verifier to agree on the same containment rule; one string
+ *    compared with `===` cannot be got wrong.
+ * 4. **The verifier cannot forget the revocation check.** {@link
+ *    verifyDeviceAssertion} takes `revoked` as a REQUIRED dependency, so a
+ *    caller that never looked the device row up does not compile. The daemon's
+ *    own local checks (see `@byok-sdk/client`'s `assertion.issue`) are only half
+ *    of revocation; the other half is this recheck at exchange time, and no
+ *    documentation may claim the daemon satisfies "synchronous invalidation"
+ *    on its own.
+ *
+ * Like `attestation.ts`, this module is crypto-free: signature verification is
+ * an injected port (`DeviceAssertionVerifier`), because core must load on
+ * Workers and `node:crypto`/WebCrypto disagree about key handling.
+ */
+import { z } from 'zod';
+import { type JsonObject } from './attestation';
+/** Envelope schema id, self-consistent with the domain prefix below. */
+export declare const DEVICE_ASSERTION_SCHEMA_ID = "byok-device-assertion-v1";
+/**
+ * Domain separation prefix, prepended to the canonical claim bytes before
+ * signing.
+ *
+ * Must remain mutually NON-PREFIX with the other two things this same Ed25519
+ * device key signs — `byok-nonce-v1\n` (challenge/token renewal, see
+ * `@byok-sdk/client`'s `device-keys.ts`) and `byok-device-proof-v1\n`
+ * (`attestation.ts`) — so no signature over one domain can ever be reinterpreted
+ * as a signature over another. `packages/core/src/__tests__/device-assertion.test.ts`
+ * asserts the three-way non-prefix property directly; that assertion is the
+ * falsifier for this whole design, not a nicety.
+ */
+export declare const DEVICE_ASSERTION_DOMAIN_PREFIX = "byok-device-assertion-v1\n";
+export declare const DEVICE_ASSERTION_VERSION = 1;
+/** Signature algorithms this envelope version admits. */
+export declare const DEVICE_ASSERTION_ALGORITHMS: readonly ['ed25519'];
+export type DeviceAssertionAlgorithm = (typeof DEVICE_ASSERTION_ALGORITHMS)[number];
+/**
+ * Default assertion lifetime. Short on purpose: the daemon keeps no `jti`
+ * ledger (it is not on the verification path and could not stop a real replay
+ * anyway), so a narrow expiry window plus a burn-on-use verifier is the whole
+ * replay story.
+ */
+export declare const DEVICE_ASSERTION_DEFAULT_TTL_MS = 120000;
+/**
+ * Hard ceiling on the lifetime, enforced at BOTH ends: a daemon refuses to be
+ * configured above it, and {@link verifyDeviceAssertion} refuses an envelope
+ * whose own `issuedAt`→`expiresAt` span exceeds it regardless of who minted it.
+ */
+export declare const DEVICE_ASSERTION_MAX_TTL_MS = 300000;
+/** Bound on the `audience` claim, in UTF-8 bytes — an allowlist entry is a short identifier, not a document. */
+export declare const DEVICE_ASSERTION_AUDIENCE_MAX_BYTES = 256;
+/**
+ * The signed claim set. `strictObject` with every member REQUIRED: an optional
+ * claim is a claim a verifier may or may not see, and this envelope is small
+ * enough that there is no honest reason for one.
+ *
+ * `issuer` is the paired server's origin (scheme + host + port, normalized) —
+ * it binds the assertion to the deployment the device is actually paired
+ * against, so an assertion minted by a device paired to a staging server cannot
+ * be presented to production.
+ */
+export declare const DeviceAssertionClaimsSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    issuer: z.ZodString;
+    productId: z.ZodString;
+    deviceId: z.ZodString;
+    audience: z.ZodString;
+    jti: z.ZodString;
+    issuedAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type DeviceAssertionClaims = z.infer<typeof DeviceAssertionClaimsSchema>;
+export declare const DeviceAssertionEnvelopeV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"byok-device-assertion-v1">;
+    algorithm: z.ZodEnum<{
+        ed25519: "ed25519";
+    }>;
+    protected: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        issuer: z.ZodString;
+        productId: z.ZodString;
+        deviceId: z.ZodString;
+        audience: z.ZodString;
+        jti: z.ZodString;
+        issuedAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    signature: z.ZodString;
+}, z.core.$strict>;
+export type DeviceAssertionEnvelopeV1 = z.infer<typeof DeviceAssertionEnvelopeV1Schema>;
+/**
+ * Parses an envelope fail-closed.
+ *
+ * @throws {ByokCoreError} code `assertion_envelope_invalid`.
+ */
+export declare function parseDeviceAssertionEnvelope(input: unknown): DeviceAssertionEnvelopeV1;
+/**
+ * Projects claims into the exact JSON object that gets canonicalized.
+ *
+ * Built field by field rather than by spreading the parsed object — the same
+ * discipline `deviceProofCanonicalClaims` documents. Nothing here is optional,
+ * so there is no absent-key decision to get wrong; the explicit projection is
+ * what keeps it that way if a field is ever added.
+ */
+export declare function deviceAssertionCanonicalClaims(claims: DeviceAssertionClaims): JsonObject;
+/** Canonical JSON text of the claim set, without the domain prefix. */
+export declare function deviceAssertionCanonicalJson(claims: DeviceAssertionClaims): string;
+/**
+ * The exact bytes a device signs and a verifier reconstructs:
+ * `byok-device-assertion-v1\n` followed by the canonical claim JSON, UTF-8
+ * encoded.
+ *
+ * Frozen by `src/__tests__/golden/device-assertion-v1.canonical.json`.
+ */
+export declare function deviceAssertionSigningInput(claims: DeviceAssertionClaims): Uint8Array;
+export interface DeviceAssertionVerifyInput {
+    readonly algorithm: DeviceAssertionAlgorithm;
+    /** Raw public key, base64url — the JWK `x` encoding the device registry stores. */
+    readonly publicKey: string;
+    readonly signature: string;
+    readonly signingInput: Uint8Array;
+}
+/**
+ * Injected signature verification, for the same reason `DeviceProofVerifier`
+ * exists: core is Node-free and Workers-safe, so it answers no cryptographic
+ * question itself. Kept separate from `DeviceProofVerifier` even though the
+ * shapes coincide — one composition object satisfies both — because this file's
+ * entire purpose is that the two domains never become interchangeable, and a
+ * shared type is the first step toward a shared code path.
+ */
+export interface DeviceAssertionVerifier {
+    verify(input: DeviceAssertionVerifyInput): Promise<boolean>;
+}
+/**
+ * The device-row fields a verification reads — the verifier's OWN directory
+ * row, resolved by `deviceId`, never anything the envelope carried.
+ *
+ * Both fields together, from one lookup, are what make forgetting impossible:
+ * the caller cannot obtain `publicKeyJwkX` without also obtaining the current
+ * `revoked` state, because they arrive as one object from one call.
+ */
+export interface DeviceAssertionDeviceRow {
+    /** JWK `x` of the device's registered Ed25519 public key. The ONLY key a signature is ever checked against. */
+    readonly publicKeyJwkX: string;
+    /** The row's CURRENT revocation state, read in the same lookup as the key. */
+    readonly revoked: boolean;
+}
+/**
+ * Everything a verification needs that is NOT in the envelope.
+ *
+ * The device row is supplied through a LOOKUP PORT, not as a pre-fetched
+ * value, and that is the whole point (this is the faithful clone of
+ * `DeviceProofVerifier`'s "core is never a second authority on device
+ * identity" shape). `verifyDeviceAssertion` reads `deviceId` from the parsed
+ * claims and calls `lookupDevice(deviceId)` ITSELF, so:
+ *
+ * - There is no way to invoke a verification without providing the means to
+ *   look the current row up — "I forgot to check revocation" cannot be
+ *   expressed, because the function does the lookup, not the caller.
+ * - Both the public key AND the revocation state come from that one row, so a
+ *   caller cannot pass a key while claiming `revoked: false` from thin air.
+ * - The `deviceId` handed to `lookupDevice` is the claimed one; the row it
+ *   returns is authority. A device asserting an identity it is not is caught
+ *   by the lookup missing, or by the returned row's key failing the signature.
+ */
+export interface DeviceAssertionVerifyDeps {
+    readonly verifier: DeviceAssertionVerifier;
+    /**
+     * Resolve the verifier's own device row by the claimed `deviceId`.
+     * `undefined` for an unknown device. Sync or async; awaited either way.
+     */
+    readonly lookupDevice: (deviceId: string) => Promise<DeviceAssertionDeviceRow | undefined> | DeviceAssertionDeviceRow | undefined;
+    /** Injected instant — core never reads a wall clock (`stores.ts`'s `Clock`). */
+    readonly now: Date;
+    /** Bound on `issuedAt`→`expiresAt`. Defaults to (and may never exceed) {@link DEVICE_ASSERTION_MAX_TTL_MS}. */
+    readonly maxLifetimeMs?: number;
+}
+/**
+ * Verifies an assertion and returns its claims, or `undefined`.
+ *
+ * Every rejected state collapses to `undefined` — malformed input, an unknown
+ * or revoked device, an expired or over-long window, a bad signature — so a
+ * route has one response for all of them and cannot accidentally leak which
+ * check failed. That is the same shape `authenticateDeviceProof`
+ * (`@byok-sdk/cloud`) already uses.
+ *
+ * The row lookup and both authority reads (key, revocation) happen INSIDE this
+ * function — see {@link DeviceAssertionVerifyDeps}. What the caller MUST still
+ * do afterward, and this cannot: assert `claims.audience` equals the audience
+ * it actually serves, assert `claims.issuer`/`claims.productId` match its own
+ * deployment, and BURN `claims.jti` so the assertion cannot be presented
+ * twice. The daemon keeps no `jti` ledger; single use is entirely the
+ * verifier's job.
+ */
+export declare function verifyDeviceAssertion(input: unknown, deps: DeviceAssertionVerifyDeps): Promise<DeviceAssertionClaims | undefined>;

package/dist/errors.d.ts

@@ -36,6 +36,7 @@ export declare const CORE_ERROR_CODES: {
     readonly capability_unavailable: 'capability_unavailable';
     readonly proof_envelope_invalid: 'proof_envelope_invalid';
     readonly proof_canonicalization_failed: 'proof_canonicalization_failed';
+    readonly assertion_envelope_invalid: 'assertion_envelope_invalid';
     readonly mailbox_message_not_found: 'mailbox_message_not_found';
     readonly mailbox_cursor_regression: 'mailbox_cursor_regression';
     readonly board_item_not_found: 'board_item_not_found';
@@ -51,6 +52,7 @@ export declare const CORE_ERROR_CODES: {
     readonly activity_batch_invalid: 'activity_batch_invalid';
     readonly hint_ttl_invalid: 'hint_ttl_invalid';
     readonly hint_rate_limited: 'hint_rate_limited';
+    readonly object_key_prefix_invalid: 'object_key_prefix_invalid';
     readonly object_not_found: 'object_not_found';
     readonly object_state_invalid: 'object_state_invalid';
     readonly storage_entitlement_missing: 'storage_entitlement_missing';
@@ -61,6 +63,8 @@ export declare const CORE_ERROR_CODES: {
     readonly storage_reservation_expired: 'storage_reservation_expired';
     readonly storage_integrity_mismatch: 'storage_integrity_mismatch';
     readonly storage_write_suspended: 'storage_write_suspended';
+    readonly skill_pack_manifest_invalid: 'skill_pack_manifest_invalid';
+    readonly skill_pack_frontmatter_invalid: 'skill_pack_frontmatter_invalid';
 };
 export type CoreErrorCode = (typeof CORE_ERROR_CODES)[keyof typeof CORE_ERROR_CODES];
 /** Base error for every failure this package raises. */

package/dist/in-memory/index.d.ts

@@ -6,6 +6,7 @@ export { InMemoryTruthStore } from './truth';
 export { InMemoryPresenceStore, InMemoryActivityStore } from './presence';
 export { InMemoryObjectStore } from './blob';
 export { InMemoryQuotaStore } from './quota';
+export { InMemorySkillPackStore } from './skill-pack';
 export interface InMemoryCoreOptions {
     /** Defaults to a fresh {@link createMutableClock}, so TTL behavior is deterministic. */
     readonly clock?: Clock;

package/dist/in-memory/skill-pack.d.ts

@@ -0,0 +1,25 @@
+/**
+ * In-memory {@link SkillPackStore} reference (plan `skill-pack-delivery-channel`).
+ *
+ * The interesting property is what `publish` refuses. This store cannot hash —
+ * core has no crypto — so it is NOT the integrity authority for a pack, and it
+ * does not pretend to be: the publisher mints the addresses and the installing
+ * device re-derives and verifies every one of them. What this store CAN check
+ * without crypto, it checks, and rejects rather than storing a pack whose
+ * manifest and bytes already disagree at publish time: the declared path set
+ * must be exactly the delivered path set, and every delivered file's UTF-8 byte
+ * length must equal what its row declared.
+ *
+ * Storing that pair unchecked would be the worse failure mode by far — the
+ * device would fetch, verify, reject, and have no way to tell a corrupt
+ * publication from a tampered response.
+ */
+import { type SkillPackFileContent, type SkillPackListQuery, type SkillPackManifest, type SkillPackPublishInput, type SkillPackStore } from '../skill-pack';
+import { type TenantId } from '../tenant';
+export declare class InMemorySkillPackStore implements SkillPackStore {
+    #private;
+    publish(tenant: TenantId, input: SkillPackPublishInput): Promise<SkillPackManifest>;
+    get(tenant: TenantId, name: string): Promise<SkillPackManifest | undefined>;
+    list(tenant: TenantId, query: SkillPackListQuery): Promise<readonly SkillPackManifest[]>;
+    readFile(tenant: TenantId, name: string, path: string): Promise<SkillPackFileContent | undefined>;
+}

package/dist/index.d.ts

@@ -18,23 +18,28 @@ export { ByokCoreError, CoreConflictError, CORE_ERROR_CODES, isCoreError, isCore
 export type { CoreErrorCode } from './errors';
 export { CANONICAL_TIMESTAMP_PATTERN, assertCanonicalTimestamp, isCanonicalTimestamp, } from './time';
 export { MAILBOX_MESSAGE_STATES } from './mailbox';
-export type { MailboxAdvanceCursorInput, MailboxAppendInput, MailboxCursorState, MailboxMessage, MailboxMessageState, MailboxPage, MailboxReadQuery, MailboxRetentionInput, MailboxRetentionResult, MailboxStore, } from './mailbox';
+export type { MailboxAdvanceCursorInput, MailboxAppendInput, MailboxBody, MailboxCursorState, MailboxMessage, MailboxMessageState, MailboxPage, MailboxReadQuery, MailboxRetentionInput, MailboxRetentionResult, MailboxStore, } from './mailbox';
 export { BOARD_STATUSES, BOARD_TRANSITIONS, isLegalBoardTransition } from './board';
 export type { BoardAssignee, BoardClaimInput, BoardItem, BoardItemInput, BoardListQuery, BoardPage, BoardStatus, BoardStatusUpdateInput, BoardStore, BoardUnclaimInput, } from './board';
 export { TRUTH_RECORD_KINDS } from './truth';
 export type { SnapshotWriteInput, TerminalWriteInput, TruthBodyRef, TruthManifestEntry, TruthManifestQuery, TruthRecord, TruthRecordKind, TruthRecordSelector, TruthStore, } from './truth';
 export { PRESENCE_LEVELS, DEFAULT_ACTIVITY_CAPACITY } from './presence';
 export type { ActivityAppendInput, ActivityEntry, ActivityStore, ActivityTail, PresenceHint, PresenceHintInput, PresenceLevel, PresenceStore, } from './presence';
-export { CONTENT_HASH_PATTERN, OBJECT_STATES, OBJECT_STATE_TRANSITIONS, contentHash, isContentHash, isLegalObjectTransition, tenantObjectKey, } from './blob';
-export type { ContentHash, ObjectCommitInput, ObjectListQuery, ObjectManifestEntry, ObjectManifestInput, ObjectReference, ObjectReferenceInput, ObjectState, ObjectStore, } from './blob';
+export { CONTENT_HASH_PATTERN, OBJECT_KEY_PREFIX_PATTERN, OBJECT_STATES, OBJECT_STATE_TRANSITIONS, contentHash, isContentHash, isLegalObjectTransition, objectKeyPrefix, tenantObjectKey, } from './blob';
+export type { ContentHash, ObjectCommitInput, ObjectKeyPrefix, ObjectListQuery, ObjectManifestEntry, ObjectManifestInput, ObjectReference, ObjectReferenceInput, ObjectState, ObjectStore, } from './blob';
 export { STORAGE_ERROR_CODES, STORAGE_ERROR_HTTP_STATUS, STORAGE_RESERVATION_STATES, STORAGE_WRITE_KINDS, STORAGE_WRITE_POSTURES, } from './quota';
 export type { MailboxUsageDeltaInput, QuotaStore, StorageErrorCode, StorageFinalizeInput, StorageFinalizeResult, StorageReservation, StorageReservationInput, StorageReservationState, StorageStatus, StorageWriteKind, StorageWritePosture, TenantStorageEntitlement, TenantStorageEntitlementInput, TenantStorageUsage, } from './quota';
 export { CAPABILITY_DECLARATION_SCHEMA_ID, CAPABILITY_NAME_PATTERN, CapabilityDeclarationSchema, assertCapability, hasCapability, parseCapabilityDeclaration, } from './capabilities';
 export type { CapabilityDeclaration } from './capabilities';
+export { SKILL_FRONTMATTER_FIELDS, SKILL_PACK_DESCRIPTION_MAX_LENGTH, SKILL_PACK_ENTRY_PATH, SKILL_PACK_FILE_MAX_BYTES, SKILL_PACK_FILE_PATH_MAX_LENGTH, SKILL_PACK_FILE_PATH_PATTERN, SKILL_PACK_FORBIDDEN_FIELDS, SKILL_PACK_MANIFEST_SCHEMA_ID, SKILL_PACK_MAX_BYTES, SKILL_PACK_MAX_FILES, SKILL_PACK_NAME_MAX_LENGTH, SKILL_PACK_NAME_PATTERN, SKILL_PACK_REJECTIONS, SKILL_PACK_VERSION_PATTERN, SkillPackFileSchema, SkillPackManifestSchema, checkSkillPackEntry, checkSkillPackFileContent, checkSkillPackManifest, isSkillPackPathSafe, parseSkillFrontmatter, parseSkillPackManifest, skillPackContentHashInput, } from './skill-pack';
+export type { ObservedSkillPackFile, SkillFrontmatter, SkillPackCheck, SkillPackFile, SkillPackFileContent, SkillPackListQuery, SkillPackManifest, SkillPackPublishInput, SkillPackRejection, SkillPackStore, } from './skill-pack';
 export { CORE_STORE_NAMES } from './stores';
 export type { Clock, CoreStoreName, CoreStores, MutableClock } from './stores';
-export { CORE_PORT_INTERFACES, CORE_PORT_METHODS } from './ports-contract';
-export { DEVICE_PROOF_ALGORITHMS, DEVICE_PROOF_DOMAIN_PREFIX, DEVICE_PROOF_SCHEMA_ID, DEVICE_PROOF_VERSION, DeviceProofEnvelopeV1Schema, DeviceProofProtectedClaimsSchema, canonicalizeJson, canonicalizeJsonBytes, deviceProofCanonicalClaims, deviceProofCanonicalJson, deviceProofSigningInput, parseDeviceProofEnvelope, } from './attestation';
+export { CORE_NON_COMPOSITION_PORT_NAMES, CORE_PORT_INTERFACES, CORE_PORT_METHODS, } from './ports-contract';
+export { DEVICE_PROOF_ALGORITHMS, DEVICE_PROOF_DOMAIN_PREFIX, DEVICE_PROOF_HEADER, DEVICE_PROOF_SCHEMA_ID, DEVICE_PROOF_VERSION, DeviceProofEnvelopeV1Schema, DeviceProofProtectedClaimsSchema, canonicalizeJson, canonicalizeJsonBytes, deviceProofCanonicalClaims, deviceProofCanonicalJson, deviceProofSigningInput, parseDeviceProofEnvelope, } from './attestation';
 export type { DeviceProofAlgorithm, DeviceProofEnvelopeV1, DeviceProofProtectedClaims, DeviceProofVerifier, DeviceProofVerifyInput, JsonObject, JsonPrimitive, JsonValue, } from './attestation';
-export { IN_MEMORY_CLOCK_EPOCH, InMemoryActivityStore, InMemoryBoardStore, InMemoryMailboxStore, InMemoryObjectStore, InMemoryPresenceStore, InMemoryQuotaStore, InMemoryTruthStore, createInMemoryCoreStores, createInMemoryCoreCompositionWithClock, createMutableClock, } from './in-memory/index';
+export { DEVICE_ASSERTION_ALGORITHMS, DEVICE_ASSERTION_AUDIENCE_MAX_BYTES, DEVICE_ASSERTION_DEFAULT_TTL_MS, DEVICE_ASSERTION_DOMAIN_PREFIX, DEVICE_ASSERTION_MAX_TTL_MS, DEVICE_ASSERTION_SCHEMA_ID, DEVICE_ASSERTION_VERSION, DeviceAssertionClaimsSchema, DeviceAssertionEnvelopeV1Schema, deviceAssertionCanonicalClaims, deviceAssertionCanonicalJson, deviceAssertionSigningInput, parseDeviceAssertionEnvelope, verifyDeviceAssertion, } from './device-assertion';
+export type { DeviceAssertionAlgorithm, DeviceAssertionClaims, DeviceAssertionDeviceRow, DeviceAssertionEnvelopeV1, DeviceAssertionVerifier, DeviceAssertionVerifyDeps, DeviceAssertionVerifyInput, } from './device-assertion';
+export { NONCE_SIGNING_DOMAIN, nonceSigningBytes } from './pairing';
+export { IN_MEMORY_CLOCK_EPOCH, InMemoryActivityStore, InMemoryBoardStore, InMemoryMailboxStore, InMemoryObjectStore, InMemoryPresenceStore, InMemoryQuotaStore, InMemorySkillPackStore, InMemoryTruthStore, createInMemoryCoreStores, createInMemoryCoreCompositionWithClock, createMutableClock, } from './in-memory/index';
 export type { InMemoryCoreComposition, InMemoryCoreOptions } from './in-memory/index';