@arcforges/proto 1.0.0-ci.101.1

package/dist/values/gen/identifiers.d.ts

@@ -0,0 +1,79 @@
+import type { Id } from "../../gen/arcforges/foundation/v1/foundation_pb.js";
+declare const identifierBrand: unique symbol;
+export type IdentifierDomain = "RealmId" | "UserId" | "WorkspaceId" | "DeviceId" | "InstallationId" | "InstanceId" | "CommandId" | "CorrelationId" | "ResourceId" | "BlobId" | "ArtifactId" | "ContentOriginId" | "ContentUnitId" | "ConflictId" | "DelegationId" | "TaskId" | "RunId" | "StepId" | "AttemptId" | "InvocationId" | "ApprovalId" | "AutomationId" | "ConversationId" | "BranchId" | "MessageId" | "ProjectId" | "AgentProfileId" | "SkillId" | "FolderId" | "DocumentId" | "BlockId" | "NotebookId" | "TagId" | "PropertyDefId" | "ViewId" | "SessionRecordId" | "CaptureId" | "SegmentId" | "ChannelId" | "FindingId" | "SequenceId" | "TrackId" | "TimelineItemId" | "MediaAssetId" | "EffectInstanceId" | "SlateProjectId" | "ChatTurnId" | "ExecutionStreamId" | "ProductJobId" | "ToolProposalId" | "MemoryId" | "PreferenceId" | "GrantId" | "InlineId" | "TextRunId" | "TableRowId" | "TableCellId" | "SelectOptionId" | "ScopeConfigurationId" | "ScopeProjectId" | "ScopeAnnotationId" | "ScopeEventId" | "SelectionId" | "SourceConsentId" | "MediaBinId" | "TimelineGroupId" | "TimelineLinkGroupId" | "TimelineMarkerId" | "TransitionId";
+export type DomainId<T extends IdentifierDomain> = string & {
+    readonly [identifierBrand]: T;
+};
+export declare function parseId<T extends IdentifierDomain>(domain: T, value: string): DomainId<T>;
+export declare function idFromWire<T extends IdentifierDomain>(domain: T, value: Id): DomainId<T>;
+export declare function idToWire<T extends IdentifierDomain>(domain: T, value: DomainId<NoInfer<T>>): Id;
+export type RealmId = DomainId<"RealmId">;
+export type UserId = DomainId<"UserId">;
+export type WorkspaceId = DomainId<"WorkspaceId">;
+export type DeviceId = DomainId<"DeviceId">;
+export type InstallationId = DomainId<"InstallationId">;
+export type InstanceId = DomainId<"InstanceId">;
+export type CommandId = DomainId<"CommandId">;
+export type CorrelationId = DomainId<"CorrelationId">;
+export type ResourceId = DomainId<"ResourceId">;
+export type BlobId = DomainId<"BlobId">;
+export type ArtifactId = DomainId<"ArtifactId">;
+export type ContentOriginId = DomainId<"ContentOriginId">;
+export type ContentUnitId = DomainId<"ContentUnitId">;
+export type ConflictId = DomainId<"ConflictId">;
+export type DelegationId = DomainId<"DelegationId">;
+export type TaskId = DomainId<"TaskId">;
+export type RunId = DomainId<"RunId">;
+export type StepId = DomainId<"StepId">;
+export type AttemptId = DomainId<"AttemptId">;
+export type InvocationId = DomainId<"InvocationId">;
+export type ApprovalId = DomainId<"ApprovalId">;
+export type AutomationId = DomainId<"AutomationId">;
+export type ConversationId = DomainId<"ConversationId">;
+export type BranchId = DomainId<"BranchId">;
+export type MessageId = DomainId<"MessageId">;
+export type ProjectId = DomainId<"ProjectId">;
+export type AgentProfileId = DomainId<"AgentProfileId">;
+export type SkillId = DomainId<"SkillId">;
+export type FolderId = DomainId<"FolderId">;
+export type DocumentId = DomainId<"DocumentId">;
+export type BlockId = DomainId<"BlockId">;
+export type NotebookId = DomainId<"NotebookId">;
+export type TagId = DomainId<"TagId">;
+export type PropertyDefId = DomainId<"PropertyDefId">;
+export type ViewId = DomainId<"ViewId">;
+export type SessionRecordId = DomainId<"SessionRecordId">;
+export type CaptureId = DomainId<"CaptureId">;
+export type SegmentId = DomainId<"SegmentId">;
+export type ChannelId = DomainId<"ChannelId">;
+export type FindingId = DomainId<"FindingId">;
+export type SequenceId = DomainId<"SequenceId">;
+export type TrackId = DomainId<"TrackId">;
+export type TimelineItemId = DomainId<"TimelineItemId">;
+export type MediaAssetId = DomainId<"MediaAssetId">;
+export type EffectInstanceId = DomainId<"EffectInstanceId">;
+export type SlateProjectId = DomainId<"SlateProjectId">;
+export type ChatTurnId = DomainId<"ChatTurnId">;
+export type ExecutionStreamId = DomainId<"ExecutionStreamId">;
+export type ProductJobId = DomainId<"ProductJobId">;
+export type ToolProposalId = DomainId<"ToolProposalId">;
+export type MemoryId = DomainId<"MemoryId">;
+export type PreferenceId = DomainId<"PreferenceId">;
+export type GrantId = DomainId<"GrantId">;
+export type InlineId = DomainId<"InlineId">;
+export type TextRunId = DomainId<"TextRunId">;
+export type TableRowId = DomainId<"TableRowId">;
+export type TableCellId = DomainId<"TableCellId">;
+export type SelectOptionId = DomainId<"SelectOptionId">;
+export type ScopeConfigurationId = DomainId<"ScopeConfigurationId">;
+export type ScopeProjectId = DomainId<"ScopeProjectId">;
+export type ScopeAnnotationId = DomainId<"ScopeAnnotationId">;
+export type ScopeEventId = DomainId<"ScopeEventId">;
+export type SelectionId = DomainId<"SelectionId">;
+export type SourceConsentId = DomainId<"SourceConsentId">;
+export type MediaBinId = DomainId<"MediaBinId">;
+export type TimelineGroupId = DomainId<"TimelineGroupId">;
+export type TimelineLinkGroupId = DomainId<"TimelineLinkGroupId">;
+export type TimelineMarkerId = DomainId<"TimelineMarkerId">;
+export type TransitionId = DomainId<"TransitionId">;
+export {};

package/dist/values/gen/identifiers.js

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+// <auto-generated />
+// Generated by eng/generate_shapes.py; do not edit.
+import { create } from "@bufbuild/protobuf";
+import { IdSchema } from "../../gen/arcforges/foundation/v1/foundation_pb.js";
+export function parseId(domain, value) {
+    if (typeof domain !== 'string' || !identifierDomains.has(domain) || typeof value !== 'string' || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.exec(value)?.[0] !== value || value === '00000000-0000-0000-0000-000000000000')
+        throw new TypeError('Invalid canonical domain identity');
+    return value;
+}
+export function idFromWire(domain, value) {
+    if (!(value?.value instanceof Uint8Array) || value.value.length !== 16 || !value.value.some(v => v !== 0))
+        throw new TypeError('Invalid wire UUID');
+    const h = Array.from(value.value, v => v.toString(16).padStart(2, '0')).join('');
+    return parseId(domain, `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`);
+}
+export function idToWire(domain, value) {
+    const digits = parseId(domain, value).replaceAll('-', '');
+    const bytes = Uint8Array.from({ length: 16 }, (_, i) => Number.parseInt(digits.slice(i * 2, i * 2 + 2), 16));
+    return create(IdSchema, { value: bytes });
+}
+const identifierDomains = new Set(["RealmId", "UserId", "WorkspaceId", "DeviceId", "InstallationId", "InstanceId", "CommandId", "CorrelationId", "ResourceId", "BlobId", "ArtifactId", "ContentOriginId", "ContentUnitId", "ConflictId", "DelegationId", "TaskId", "RunId", "StepId", "AttemptId", "InvocationId", "ApprovalId", "AutomationId", "ConversationId", "BranchId", "MessageId", "ProjectId", "AgentProfileId", "SkillId", "FolderId", "DocumentId", "BlockId", "NotebookId", "TagId", "PropertyDefId", "ViewId", "SessionRecordId", "CaptureId", "SegmentId", "ChannelId", "FindingId", "SequenceId", "TrackId", "TimelineItemId", "MediaAssetId", "EffectInstanceId", "SlateProjectId", "ChatTurnId", "ExecutionStreamId", "ProductJobId", "ToolProposalId", "MemoryId", "PreferenceId", "GrantId", "InlineId", "TextRunId", "TableRowId", "TableCellId", "SelectOptionId", "ScopeConfigurationId", "ScopeProjectId", "ScopeAnnotationId", "ScopeEventId", "SelectionId", "SourceConsentId", "MediaBinId", "TimelineGroupId", "TimelineLinkGroupId", "TimelineMarkerId", "TransitionId"]);

package/dist/values.d.ts

@@ -0,0 +1,56 @@
+import type { DescMessage, MessageShape } from "@bufbuild/protobuf";
+import type { Revision, NativeContentRev, LocalNotesVersion, Decimal } from "./gen/arcforges/foundation/v1/foundation_pb.js";
+export * from "./values/gen/identifiers.js";
+declare const valueBrand: unique symbol;
+type Branded<T, Name extends string> = T & {
+    readonly [valueBrand]: Name;
+};
+export type CloudRevision = Branded<bigint, "CloudRevision">;
+export type NativeRevision = Branded<bigint, "NativeRevision">;
+export type DeliverySequence = Branded<bigint, "DeliverySequence">;
+export type OpaqueCursor = Branded<string, "OpaqueCursor">;
+export type ExactDecimal = Branded<string, "ExactDecimal">;
+export type LocalNotesToken = Readonly<{
+    acknowledgedRevision: bigint;
+    headLocalSequence: bigint;
+}> & {
+    readonly [valueBrand]: "LocalNotesToken";
+};
+export declare function parseInt64(value: string): bigint;
+export declare function parseUInt64(value: string): bigint;
+export declare function cloudRevision(value: bigint): CloudRevision;
+export declare function cloudRevisionFromWire(value: Revision): CloudRevision;
+export declare function cloudRevisionToWire(value: CloudRevision): Revision;
+export declare function newRootPrecondition(): Revision;
+export declare function nativeRevision(value: bigint): NativeRevision;
+export declare function nativeRevisionFromWire(value: NativeContentRev): NativeRevision;
+export declare function nativeRevisionToWire(value: NativeRevision): NativeContentRev;
+export declare function deliverySequence(value: bigint): DeliverySequence;
+export declare function localNotesToken(acknowledgedRevision: bigint, headLocalSequence: bigint): LocalNotesToken;
+export declare function localNotesFromWire(value: LocalNotesVersion): LocalNotesToken;
+export declare function localNotesToWire(value: LocalNotesToken): LocalNotesVersion;
+export declare function opaqueCursor(value: string): OpaqueCursor;
+export declare function exactDecimal(value: string): ExactDecimal;
+export declare function notesDecimal(value: string): ExactDecimal;
+export declare function decimalFromWire(value: Decimal): ExactDecimal;
+export declare function decimalToWire(value: ExactDecimal): Decimal;
+export declare function decimalParts(value: ExactDecimal): Readonly<{
+    coefficient: bigint;
+    scale: number;
+}>;
+export declare function decimalFromCoefficient(coefficient: bigint, scale: number): ExactDecimal;
+/** Decodes compatible read data, retaining unknown fields; strict validation decides mutation suitability. */
+export declare function readProjection<T extends DescMessage>(schema: T, bytes: Uint8Array, validate: (value: unknown) => boolean): Readonly<{
+    message: MessageShape<T>;
+    knownProfile: boolean;
+}>;
+/** Re-emits a generated projection, including its inert unknown fields. */
+export declare function preserveProjection<T extends DescMessage>(schema: T, message: MessageShape<T>): Uint8Array;
+export type RationalValue = Readonly<{
+    numerator: bigint;
+    denominator: bigint;
+}> & {
+    readonly [valueBrand]: "RationalValue";
+};
+export declare function rationalValue(numerator: bigint, denominator: bigint): RationalValue;
+export declare function convertTicksExact(ticks: bigint, sourceRate: RationalValue, targetRate: RationalValue): bigint;

package/dist/values.js

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: Apache-2.0
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { RevisionSchema, NativeContentRevSchema, LocalNotesVersionSchema, DecimalSchema, } from "./gen/arcforges/foundation/v1/foundation_pb.js";
+export * from "./values/gen/identifiers.js";
+const i64min = -9223372036854775808n;
+const i64max = 9223372036854775807n;
+const u64max = 18446744073709551615n;
+export function parseInt64(value) {
+    if (typeof value !== "string" || /^(0|-?[1-9][0-9]*)$/.exec(value)?.[0] !== value)
+        throw new TypeError("Invalid canonical int64");
+    const result = BigInt(value);
+    if (result < i64min || result > i64max)
+        throw new RangeError("int64 overflow");
+    return result;
+}
+export function parseUInt64(value) {
+    if (typeof value !== "string" || /^(0|[1-9][0-9]*)$/.exec(value)?.[0] !== value)
+        throw new TypeError("Invalid canonical uint64");
+    const result = BigInt(value);
+    if (result > u64max)
+        throw new RangeError("uint64 overflow");
+    return result;
+}
+function unsigned(value) {
+    if (typeof value !== "bigint" || value < 0n || value > u64max)
+        throw new RangeError("Invalid uint64");
+    return value;
+}
+export function cloudRevision(value) {
+    if (typeof value !== "bigint" || value <= 0n || value > i64max)
+        throw new RangeError("Committed revision must be a positive int64");
+    return value;
+}
+export function cloudRevisionFromWire(value) {
+    return cloudRevision(value.value);
+}
+export function cloudRevisionToWire(value) {
+    return create(RevisionSchema, { value: cloudRevision(value) });
+}
+export function newRootPrecondition() {
+    return create(RevisionSchema, { value: 0n });
+}
+export function nativeRevision(value) {
+    return unsigned(value);
+}
+export function nativeRevisionFromWire(value) {
+    return nativeRevision(value.value);
+}
+export function nativeRevisionToWire(value) {
+    return create(NativeContentRevSchema, { value: nativeRevision(value) });
+}
+export function deliverySequence(value) {
+    return unsigned(value);
+}
+export function localNotesToken(acknowledgedRevision, headLocalSequence) {
+    if (typeof acknowledgedRevision !== "bigint" ||
+        acknowledgedRevision < 0n ||
+        acknowledgedRevision > i64max)
+        throw new RangeError("Invalid acknowledged revision");
+    return Object.freeze({
+        acknowledgedRevision,
+        headLocalSequence: unsigned(headLocalSequence),
+    });
+}
+export function localNotesFromWire(value) {
+    return localNotesToken(value.ackedRev?.value, value.headLocalSeq);
+}
+export function localNotesToWire(value) {
+    const checked = localNotesToken(value.acknowledgedRevision, value.headLocalSequence);
+    return create(LocalNotesVersionSchema, {
+        ackedRev: create(RevisionSchema, { value: checked.acknowledgedRevision }),
+        headLocalSeq: checked.headLocalSequence,
+    });
+}
+export function opaqueCursor(value) {
+    if (typeof value !== "string" || !validUnicode(value))
+        throw new TypeError("Invalid cursor Unicode");
+    let bytes = 0;
+    for (const scalar of value) {
+        const point = scalar.codePointAt(0);
+        bytes += point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4;
+    }
+    if (bytes > 4096)
+        throw new RangeError("Cursor too long");
+    return value;
+}
+export function exactDecimal(value) {
+    if (typeof value !== "string" ||
+        /^-?(0|[1-9][0-9]*)(\.[0-9]{1,9})?$/.exec(value)?.[0] !== value ||
+        (value.startsWith("-") && !/[1-9]/.test(value)) ||
+        value.replace(/[-.]/g, "").replace(/^0+/, "").length > 28)
+        throw new TypeError("Invalid exact decimal");
+    return value;
+}
+export function notesDecimal(value) {
+    const result = exactDecimal(value);
+    if (value.includes(".") && value.endsWith("0"))
+        throw new TypeError("Noncanonical Notes decimal");
+    return result;
+}
+export function decimalFromWire(value) {
+    return exactDecimal(value.value);
+}
+export function decimalToWire(value) {
+    return create(DecimalSchema, { value: exactDecimal(value) });
+}
+export function decimalParts(value) {
+    const checked = exactDecimal(value);
+    const point = checked.indexOf(".");
+    return Object.freeze({
+        coefficient: BigInt(checked.replace(".", "")),
+        scale: point < 0 ? 0 : checked.length - point - 1,
+    });
+}
+export function decimalFromCoefficient(coefficient, scale) {
+    if (typeof coefficient !== "bigint" || !Number.isInteger(scale) || scale < 0 || scale > 9)
+        throw new RangeError("Invalid exact coefficient/scale");
+    const digits = (coefficient < 0n ? -coefficient : coefficient)
+        .toString()
+        .padStart(scale + 1, "0");
+    const value = scale === 0 ? digits : `${digits.slice(0, -scale)}.${digits.slice(-scale)}`;
+    return exactDecimal(coefficient < 0n ? `-${value}` : value);
+}
+/** Decodes compatible read data, retaining unknown fields; strict validation decides mutation suitability. */
+export function readProjection(schema, bytes, validate) {
+    const message = fromBinary(schema, bytes);
+    return Object.freeze({ message, knownProfile: validate(message) });
+}
+/** Re-emits a generated projection, including its inert unknown fields. */
+export function preserveProjection(schema, message) {
+    return toBinary(schema, message);
+}
+function validUnicode(text) {
+    for (let i = 0; i < text.length; i++) {
+        const first = text.charCodeAt(i);
+        if (first < 0xd800 || first > 0xdfff)
+            continue;
+        if (first > 0xdbff || ++i >= text.length)
+            return false;
+        const second = text.charCodeAt(i);
+        if (second < 0xdc00 || second > 0xdfff)
+            return false;
+    }
+    return true;
+}
+export function rationalValue(numerator, denominator) {
+    if (typeof numerator !== "bigint" ||
+        numerator < i64min ||
+        numerator > i64max ||
+        typeof denominator !== "bigint" ||
+        denominator <= 0n ||
+        denominator > u64max)
+        throw new RangeError("Invalid rational components");
+    let a = numerator < 0n ? -numerator : numerator;
+    let b = denominator;
+    while (b !== 0n) {
+        const remainder = a % b;
+        a = b;
+        b = remainder;
+    }
+    if (a !== 1n)
+        throw new TypeError("Rational is not reduced");
+    return Object.freeze({ numerator, denominator });
+}
+export function convertTicksExact(ticks, sourceRate, targetRate) {
+    if (typeof ticks !== "bigint" || ticks < i64min || ticks > i64max)
+        throw new RangeError("Invalid signed ticks");
+    const source = rationalValue(sourceRate.numerator, sourceRate.denominator);
+    const target = rationalValue(targetRate.numerator, targetRate.denominator);
+    if (source.numerator <= 0n || target.numerator <= 0n)
+        throw new RangeError("Timebase must be positive");
+    const numerator = ticks * target.numerator * source.denominator;
+    const denominator = source.numerator * target.denominator;
+    const result = numerator / denominator;
+    if (numerator % denominator !== 0n || result < i64min || result > i64max)
+        throw new RangeError("Time is not representable");
+    return result;
+}

package/dist/wire.d.ts

@@ -0,0 +1,34 @@
+import type { DescMessage, MessageShape } from "@bufbuild/protobuf";
+/** The registry's fixed decode and encode bounds. */
+export declare const wireLimits: Readonly<{
+    readonly unaryMessage: number;
+    readonly helperMessage: number;
+    readonly inlinePage: number;
+    readonly streamFrame: number;
+    readonly largeProjection: number;
+    /** Message levels permitted below the root message. */
+    readonly nestedMessageLevels: 100;
+}>;
+/** Selected transport size classes from the wire registry. */
+export type WireLimit = Exclude<keyof typeof wireLimits, "nestedMessageLevels">;
+/** Why a bounded contract encode or decode was refused. */
+export type ContractSerializationFailure = "tooLarge" | "tooDeep" | "malformed" | "invalid";
+/** A typed refusal from a bounded contract codec; the message never carries payload content. */
+export declare class ContractSerializationError extends Error {
+    readonly failure: ContractSerializationFailure;
+    constructor(failure: ContractSerializationFailure, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * protobuf-es read options matching the C# decoder: unknown fields are retained
+ * and the root plus 100 nested message levels are admitted (protobuf-es counts the root).
+ */
+export declare const contractBinaryReadOptions: Readonly<{
+    readUnknownFields: true;
+    recursionLimit: number;
+}>;
+/** Decodes one complete message or throws a typed refusal. */
+export declare function decodeContract<Desc extends DescMessage>(schema: Desc, bytes: Uint8Array, limit: WireLimit): MessageShape<Desc>;
+/** Encodes a message only when its serialized size fits the selected class. */
+export declare function encodeContract<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>, limit: WireLimit): Uint8Array;

package/dist/wire.js

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+import { fromBinary, toBinary } from "@bufbuild/protobuf";
+/** The registry's fixed decode and encode bounds. */
+export const wireLimits = Object.freeze({
+    unaryMessage: 4 * 1024 * 1024,
+    helperMessage: 4 * 1024 * 1024,
+    inlinePage: 256 * 1024,
+    streamFrame: 32 * 1024,
+    largeProjection: 64 * 1024 * 1024,
+    /** Message levels permitted below the root message. */
+    nestedMessageLevels: 100,
+});
+/** A typed refusal from a bounded contract codec; the message never carries payload content. */
+export class ContractSerializationError extends Error {
+    failure;
+    constructor(failure, options) {
+        super(`Contract serialization refused: ${failure}.`, options);
+        this.name = "ContractSerializationError";
+        this.failure = failure;
+    }
+}
+/**
+ * protobuf-es read options matching the C# decoder: unknown fields are retained
+ * and the root plus 100 nested message levels are admitted (protobuf-es counts the root).
+ */
+export const contractBinaryReadOptions = Object.freeze({
+    readUnknownFields: true,
+    recursionLimit: wireLimits.nestedMessageLevels + 1,
+});
+/** Decodes one complete message or throws a typed refusal. */
+export function decodeContract(schema, bytes, limit) {
+    if (bytes.byteLength > wireLimits[limit])
+        throw new ContractSerializationError("tooLarge");
+    try {
+        return fromBinary(schema, bytes, contractBinaryReadOptions);
+    }
+    catch (error) {
+        // protobuf-es reports recursion exhaustion through its fixed depth message.
+        const deep = error instanceof Error && error.message.includes("maximum recursion depth");
+        throw new ContractSerializationError(deep ? "tooDeep" : "malformed", { cause: error });
+    }
+}
+/** Encodes a message only when its serialized size fits the selected class. */
+export function encodeContract(schema, message, limit) {
+    const bytes = toBinary(schema, message, { writeUnknownFields: true });
+    if (bytes.byteLength > wireLimits[limit])
+        throw new ContractSerializationError("tooLarge");
+    return bytes;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@arcforges/proto",
+  "version": "1.0.0-ci.101.1",
+  "description": "ArcForges public foundation and domain protobuf messages, shape validation and exact value adapters.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ArcForges/Contracts.git",
+    "directory": "src/public/ts/proto"
+  },
+  "homepage": "https://github.com/ArcForges/Contracts#readme",
+  "bugs": {
+    "url": "https://github.com/ArcForges/Contracts/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./build-identity": "./build-identity.json"
+  },
+  "files": [
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "build-identity.json",
+    "contracts.binpb",
+    "dist",
+    "proto",
+    "sbom.cdx.json",
+    "schemas",
+    "source.json"
+  ],
+  "dependencies": {
+    "@bufbuild/protobuf": "2.15.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "arcforges": {
+    "licenceBoundary": "Apache",
+    "contractAccess": "public"
+  }
+}

package/sbom.cdx.json

@@ -0,0 +1,45 @@
+{
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.6",
+  "version": 1,
+  "metadata": {
+    "component": {
+      "type": "library",
+      "bom-ref": "pkg:npm/%40arcforges/proto@1.0.0-ci.101.1",
+      "name": "@arcforges/proto",
+      "version": "1.0.0-ci.101.1",
+      "purl": "pkg:npm/%40arcforges/proto@1.0.0-ci.101.1",
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ]
+    }
+  },
+  "components": [
+    {
+      "type": "library",
+      "bom-ref": "pkg:npm/%40bufbuild/protobuf@2.15.0",
+      "name": "@bufbuild/protobuf",
+      "version": "2.15.0",
+      "purl": "pkg:npm/%40bufbuild/protobuf@2.15.0",
+      "licenses": [
+        {
+          "expression": "(Apache-2.0 AND BSD-3-Clause)"
+        }
+      ]
+    }
+  ],
+  "dependencies": [
+    {
+      "ref": "pkg:npm/%40bufbuild/protobuf@2.15.0",
+      "dependsOn": []
+    },
+    {
+      "ref": "pkg:npm/%40arcforges/proto@1.0.0-ci.101.1",
+      "dependsOn": [
+        "pkg:npm/%40bufbuild/protobuf@2.15.0"
+      ]
+    }
+  ]
+}

package/schemas/public/proto/arcforges/events/v1/events.proto

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+syntax = "proto3";
+
+package arcforges.events.v1;
+
+option csharp_namespace = "ArcForges.Contracts.Events.V1";
+option java_package = "io.github.arcforges.contracts.events.v1";
+option java_multiple_files = true;
+option java_outer_classname = "EventsProto";
+
+// The complete entitlement.changed hint payload; not the full Event envelope.
+message EntitlementChanged {
+  optional int64 entitlement_version = 1 [json_name = "entitlementVersion"];
+}