TypeScript 初回アドミッションと履歴信頼

TypeScript AdmissionService は、6 段階の Signed Document 検証者 (MWP-ADM-005) の上に、初回アドミッションと履歴信頼を重ねます。言語に依存しないフローはローカルの初回アドミッションと履歴信頼のランタイムページであり、正確な要件はローカルの First-Admission and Historical-Trust 句です。

パブリックアダプターと結果

パブリック API	責任
`AdmissionCurrentKeyResolver.resolveCurrent`	デプロイメントがこの決定に対して最新であることを示す完全な Organization 全体の Registry 証拠を同期的に返します。
`TrustedAdmissionContext.issue`	権威ある不存在判定の後にだけ、信頼できるレコード ID、受け入れ時刻、および受け入れサービスを同期または非同期で発行します。
`AdmissionLog.lookup`	`{ status: "found", record }` または `{ status: "authoritative-absence" }` を非同期的に返します。キャッシュミス、タイムアウト、認証されていない不在、および不定状態は MWP-ADM-003 に基づいてフェールクローズされます。
`AdmissionLog.appendOrReturnExisting`	候補バイトをアトミックに追加するか、認証されたサービス ID を通じて同時に権威のある勝者を返します。
`AuthenticatedAdmissionRecord`	MWP-ADM-009 が返されたレコードを検証できるように、`recordBytes` をアダプターによって認証されたサービスにバインドします。
`AdmissionService.prepareFirstAdmission`	SDK によって生成された `VerifiedSignedDocument` から候補証拠を作成し、検証します。追加したり、受け入れを暗示したりするものではありません。
`AdmissionService.admitFirst`	MWP-ADM-006 に基づいて、現在の検証、権威ある検索、候補の作成、アトミックな追加または既存の戻り、および返されたレコードの検証を実行します。
`AdmissionService.verifyHistoricalAdmission`	過去の Registry 証拠を使用して 6 段階の検証を再実行し、MWP-ADM-008.
`AdmittedSignedDocument`	不変の `verified` および `record` の証拠に加えて、防御的な `recordBytes` のコピーを返します。

正確な権威ある不存在判定の値は { status: "authoritative-absence" } です。呼び出し元が提供する信頼ブール値はアドミッション検索結果ではないため、成功パスを選択してはなりません。

初回受付の電話順番

admitFirst は、ログを参照する前に 6 つの署名付き文書ステージをすべて完了します。見つかったレコードは検証され、信頼できるコンテキストの発行や追加を行わずに返されます。権威ある不存在判定の後、サービスは信頼できるコンテキストを発行し、正規の候補バイトを準備し、appendOrReturnExisting を呼び出し、実際に返されたレコードを検証します。同時勝者は、そのスキーマ、認証されたサービス、ドキュメントバインディング、および信頼できる時間が経過した場合にのみ受け入れられます MWP-ADM-009 および MWP-ADM-010。

歴史的なリプレイ

履歴リプレイでは、保持された Registry 履歴を使用して検証が再実行され、status: "found" が必要であり、TrustedAdmissionContext.issue または AdmissionLog.appendOrReturnExisting は呼び出されません。レコード ID が一致すると、同じ権威あるレコードが復元されたことがわかります。これらは、Command の鮮度、署名者の認可、ステートマシンの受け入れ、ポータブルログプルーフ検証を証明するものではありません。これらは MWP-ADM-013 および MWP-ADM-014 で別々のままです。

エラー曲面

AdmissionError は wireCode: "AUTH_INVALID_SIGNATURE" を公開し、保護された auditDetail.stage: "admission" を公開します。安定した保護理由は、MWP-ADM-012.

アダプターは、サポートされているアドミッション理由で AdmissionLogError をスローする場合があります。他のアダプター例外は自動的に再分類されません。デプロイメントでは、失敗を意図的にマッピングする必要があり、一般的な成功、可用性、またはキャッシュの状態を認証された証拠として扱ってはなりません。

実行可能な完全に固定された例

この例では、1 つの Ed25519 キーを決定的に取得し、完全な Registry スナップショットと署名付き Command を構築し、型指定されたメモリ内アダプターを提供します。固定シードはデモンストレーション用の素材であり、サンプル以外では決して使用しないでください。

import {
  createPrivateKey,
  createPublicKey,
  sign as nodeSign,
  type KeyObject,
} from "node:crypto";

import {
  AdmissionService,
  SignedDocumentCodec,
  SignedDocumentKind,
  canonicalJsonBytes,
  encodeBase64Url,
  sha256Hex,
  type AdmissionContextValue,
  type AdmissionCurrentKeyResolver,
  type AdmissionLog,
  type AdmissionLookup,
  type AuthenticatedAdmissionRecord,
  type KeyRegistrySnapshot,
  type KeyResolutionRequest,
  type KeyResolver,
  type Principal,
  type SigningKey,
  type TrustedAdmissionContext,
} from "@missionweaveprotocol/sdk";

const AGENT_ID = "urn:missionweaveprotocol:agent:website-example";
const KEY_ID = "urn:missionweaveprotocol:key:website-example";
const ORGANIZATION_ID = "urn:missionweaveprotocol:organization:website-example";
const ADMISSION_SERVICE: Principal = Object.freeze({
  type: "service",
  id: "urn:missionweaveprotocol:service:admission",
});

class DeterministicSigningKey implements SigningKey {
  public readonly algorithm = "Ed25519" as const;
  public readonly keyId = KEY_ID;
  public readonly publicKeyBytes: Uint8Array;
  readonly #privateKey: KeyObject;

  public constructor() {
    // prettier-ignore
    const seed = Buffer.from(Array.from({ length: 32 }, (_, index) => index + 1));
    this.#privateKey = createPrivateKey({
      format: "der",
      key: Buffer.concat([
        Buffer.from("302e020100300506032b657004220420", "hex"),
        seed,
      ]),
      type: "pkcs8",
    });
    const spki = createPublicKey(this.#privateKey).export({
      format: "der",
      type: "spki",
    });
    this.publicKeyBytes = new Uint8Array(spki.subarray(-32));
  }

  public sign(bytes: Uint8Array): Uint8Array {
    return new Uint8Array(nodeSign(null, Buffer.from(bytes), this.#privateKey));
  }
}

class CurrentRegistryFixture
  implements AdmissionCurrentKeyResolver, KeyResolver
{
  readonly #snapshot: KeyRegistrySnapshot;

  public constructor(snapshot: KeyRegistrySnapshot) {
    this.#snapshot = snapshot;
  }

  public resolveCurrent(request: KeyResolutionRequest): KeyRegistrySnapshot {
    void request;
    return this.copySnapshot();
  }

  public resolve(request: KeyResolutionRequest): KeyRegistrySnapshot {
    void request;
    return this.copySnapshot();
  }

  private copySnapshot(): KeyRegistrySnapshot {
    return {
      completeness: "organization-wide",
      organizationId: this.#snapshot.organizationId,
      bindings: this.#snapshot.bindings.map((binding) => ({
        ...binding,
        principal: { ...binding.principal },
        validityHistory: binding.validityHistory.map((entry) => ({ ...entry })),
      })),
    };
  }
}

class FixedTrustedAdmissionContext implements TrustedAdmissionContext {
  public issue(
    organizationId: string,
    signingHash: string,
  ): AdmissionContextValue {
    const logicalKeyDigest = sha256Hex(`${organizationId}\0${signingHash}`);
    return {
      admissionRecordId: `urn:missionweaveprotocol:admission-record:${logicalKeyDigest}`,
      trustedAcceptedAt: "2026-07-15T00:05:00Z",
      acceptedBy: ADMISSION_SERVICE,
    };
  }
}

function copyRecord(
  record: AuthenticatedAdmissionRecord,
): AuthenticatedAdmissionRecord {
  return {
    recordBytes: Uint8Array.from(record.recordBytes),
    authenticatedService: { ...record.authenticatedService },
  };
}

class InMemoryAdmissionLog implements AdmissionLog {
  readonly #records = new Map<string, AuthenticatedAdmissionRecord>();
  public appendCount = 0;

  public async lookup(
    organizationId: string,
    signingHash: string,
  ): Promise<AdmissionLookup> {
    const record = this.#records.get(this.key(organizationId, signingHash));
    return record
      ? { status: "found", record: copyRecord(record) }
      : { status: "authoritative-absence" };
  }

  public async appendOrReturnExisting(
    organizationId: string,
    signingHash: string,
    candidateBytes: Uint8Array,
  ): Promise<AuthenticatedAdmissionRecord> {
    const key = this.key(organizationId, signingHash);
    const existing = this.#records.get(key);
    if (existing) return copyRecord(existing);

    const candidate = copyRecord({
      recordBytes: candidateBytes,
      authenticatedService: ADMISSION_SERVICE,
    });
    this.#records.set(key, candidate);
    this.appendCount += 1;
    return copyRecord(candidate);
  }

  private key(organizationId: string, signingHash: string): string {
    return `${organizationId}\0${signingHash}`;
  }
}

async function main(): Promise<void> {
  const signingKey: SigningKey & { readonly publicKeyBytes: Uint8Array } =
    new DeterministicSigningKey();
  const registry = new CurrentRegistryFixture({
    completeness: "organization-wide",
    organizationId: ORGANIZATION_ID,
    bindings: [
      {
        keyId: KEY_ID,
        principal: { type: "agent", id: AGENT_ID },
        algorithm: "Ed25519",
        publicKey: encodeBase64Url(signingKey.publicKeyBytes),
        validFrom: "2026-07-01T00:00:00Z",
        validityHistory: [],
      },
    ],
  });

  const signedDocument = new SignedDocumentCodec().sign(
    SignedDocumentKind.Command,
    {
      protocolVersion: "0.1",
      actionId: "urn:uuid:11111111-2222-4333-8444-555555555555",
      actor: { type: "agent", id: AGENT_ID },
      sessionEpoch: 1,
      membershipEpoch: 1,
      groupId: "urn:missionweaveprotocol:group:website-example",
      kind: "message.post",
      correlationId: "urn:uuid:aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee",
      issuedAt: "2026-07-15T00:00:00Z",
      payload: { text: "Admission example" },
    },
    signingKey,
  );
  const documentBytes = canonicalJsonBytes(signedDocument);
  const admissionLog = new InMemoryAdmissionLog();
  const service = new AdmissionService();

  const first = await service.admitFirst(
    SignedDocumentKind.Command,
    documentBytes,
    registry,
    admissionLog,
    new FixedTrustedAdmissionContext(),
  );
  const historical = await service.verifyHistoricalAdmission(
    SignedDocumentKind.Command,
    documentBytes,
    registry,
    admissionLog,
  );

  if (
    !(first.record.admissionRecordId === historical.record.admissionRecordId)
  ) {
    throw new Error("historical replay returned a different Admission record");
  }
  if (!(first.verified.signingHash === historical.verified.signingHash)) {
    throw new Error("historical replay returned a different signing hash");
  }
  if (!(Buffer.compare(first.recordBytes, historical.recordBytes) === 0)) {
    throw new Error("historical replay returned different record bytes");
  }
  if (!(admissionLog.appendCount === 1)) {
    throw new Error("Admission Log did not append exactly once");
  }

  console.log("first admission:", first.record.admissionRecordId);
  console.log("historical replay:", historical.record.admissionRecordId);
}

await main();

正確な SDK チェックアウトから、次のようにタイプチェックして実行します。

npm ci
cp /absolute/path/to/examples/sdk/typescript/admission.ts examples/website-admission.ts
npm run typecheck:examples
npm run build
node --experimental-strip-types examples/website-admission.ts

このパッケージは Node.js 20 をサポートします。この .ts ソースをストリップのみで直接実行するには、Node.js 22 以降が必要です。 Node.js 20 では、発行された ESM を実行する前に、プロジェクト TypeScript ツールチェーンを使用してトランスパイルします。予期される出力には、first admission と historical replay の同じレコード ID が含まれています。また、プログラムは、一致する署名ハッシュとレコードバイト、および 1 つの追加をアサートします。