@fide.work/fcp 0.0.1-alpha.0 → 0.0.1-alpha.2

package/dist/experimental/broadcasting/registry.d.ts

@@ -8,7 +8,7 @@
  * like `simple-git` or `isomorphic-git`.
  */
 import type { AttestationResult } from "../attestation/index.js";
-import type { Statement } from "../../statement/build.js";
+import type { Statement } from "../../statement/types.js";
 /**
  * Statement object in lean JSONL format
  * Uses short keys for efficiency: s/sr, p/pr, o/or

package/dist/experimental/merkle/tree.d.ts

@@ -42,13 +42,13 @@ export interface MerkleTreeResult {
  * @example
  * ```ts
  * const result = await buildMerkleTree([
- *   'did:fide:0x00abc...',
- *   'did:fide:0x00def...',
- *   'did:fide:0x00ghi...'
+ *   'did:fide:0x0000abc...',
+ *   'did:fide:0x0000def...',
+ *   'did:fide:0x0000ghi...'
  * ]);
  *
  * console.log('Root:', result.root);
- * console.log('Proof for first leaf:', result.proofs.get('did:fide:0x00abc...'));
+ * console.log('Proof for first leaf:', result.proofs.get('did:fide:0x0000abc...'));
  * ```
  */
 export declare function buildMerkleTree(leaves: string[]): Promise<MerkleTreeResult>;
@@ -63,7 +63,7 @@ export declare function buildMerkleTree(leaves: string[]): Promise<MerkleTreeRes
  * @example
  * ```ts
  * const isValid = await verifyMerkleProof(
- *   'did:fide:0x00abc...',
+ *   'did:fide:0x0000abc...',
  *   proof,
  *   root
  * );

package/dist/experimental/merkle/tree.js

@@ -57,13 +57,13 @@ function normalizeLeaf(fideId) {
  * @example
  * ```ts
  * const result = await buildMerkleTree([
- *   'did:fide:0x00abc...',
- *   'did:fide:0x00def...',
- *   'did:fide:0x00ghi...'
+ *   'did:fide:0x0000abc...',
+ *   'did:fide:0x0000def...',
+ *   'did:fide:0x0000ghi...'
  * ]);
  *
  * console.log('Root:', result.root);
- * console.log('Proof for first leaf:', result.proofs.get('did:fide:0x00abc...'));
+ * console.log('Proof for first leaf:', result.proofs.get('did:fide:0x0000abc...'));
  * ```
  */
 export async function buildMerkleTree(leaves) {
@@ -134,7 +134,7 @@ export async function buildMerkleTree(leaves) {
  * @example
  * ```ts
  * const isValid = await verifyMerkleProof(
- *   'did:fide:0x00abc...',
+ *   'did:fide:0x0000abc...',
  *   proof,
  *   root
  * );

package/dist/fide-id/buildFideIdFromParts.d.ts

@@ -0,0 +1,2 @@
+import type { FideId } from "./types.js";
+export declare function buildFideIdFromParts(typeChar: string, sourceChar: string, fingerprint: string): FideId;

package/dist/fide-id/buildFideIdFromParts.js

@@ -0,0 +1,36 @@
+/**
+ * Build a Fide ID from type code, source code, and fingerprint (no hashing).
+ *
+ * Use when you already have the fingerprint (e.g. from a database) and need to
+ * reconstruct the full Fide ID. For computing a new Fide ID from a raw identifier,
+ * use `calculateFideId` instead.
+ *
+ * @param typeChar Entity type code (2 hex chars, e.g. "10" for Person).
+ * @param sourceChar Source type code (2 hex chars, e.g. "20" for NetworkResource).
+ * @param fingerprint Content hash fingerprint (36 hex chars).
+ * @returns The constructed Fide ID: `did:fide:0x{typeChar}{sourceChar}{fingerprint}`
+ * @throws TypeError if any argument is not a string
+ * @throws Error if format is invalid (wrong lengths or non-hex)
+ */
+import { FIDE_ID_PREFIX, FIDE_ID_FINGERPRINT_LENGTH } from "./constants.js";
+export function buildFideIdFromParts(typeChar, sourceChar, fingerprint) {
+    if (typeof typeChar !== "string") {
+        throw new TypeError(`Invalid typeChar: expected string, got ${typeof typeChar}`);
+    }
+    if (typeof sourceChar !== "string") {
+        throw new TypeError(`Invalid sourceChar: expected string, got ${typeof sourceChar}`);
+    }
+    if (typeof fingerprint !== "string") {
+        throw new TypeError(`Invalid fingerprint: expected string, got ${typeof fingerprint}`);
+    }
+    if (typeChar.length !== 2 || !/^[0-9a-f]{2}$/i.test(typeChar)) {
+        throw new Error(`Invalid typeChar: expected 2 hex chars, got "${typeChar}"`);
+    }
+    if (sourceChar.length !== 2 || !/^[0-9a-f]{2}$/i.test(sourceChar)) {
+        throw new Error(`Invalid sourceChar: expected 2 hex chars, got "${sourceChar}"`);
+    }
+    if (fingerprint.length !== FIDE_ID_FINGERPRINT_LENGTH || !/^[0-9a-f]{36}$/i.test(fingerprint)) {
+        throw new Error(`Invalid fingerprint: expected 36 hex chars, got ${fingerprint.length} chars`);
+    }
+    return `${FIDE_ID_PREFIX}${typeChar}${sourceChar}${fingerprint}`;
+}

package/dist/fide-id/calculateFideId.d.ts

@@ -3,19 +3,23 @@ import type { FideEntityType } from "./types.js";
 export { FIDE_ENTITY_TYPE_MAP };
 export type { FideEntityType };
 /**
- * Calculate a Fide ID for an entity from its type, source type, and raw identifier.
+ * Core primitive: calculate a Fide ID from type codes and raw identifier.
  *
- * Generates a unique identifier by creating a SHA-256 hash of the raw identifier,
- * then constructing a Fide ID with type and source characters followed by the last 38 hex characters.
+ * Deterministic SHA-256 hash of the raw identifier (UTF-8), then constructs
+ * `did:fide:0x` + 2 hex (type) + 2 hex (source) + first 36 hex of hash = 40 hex total.
  *
  * @param entityType The entity type.
  * @param sourceEntityType The source entity type.
- * @param rawIdentifier The raw identifier string to hash.
+ * @param rawIdentifier The raw identifier string to hash (UTF-8 encoded).
  * @paramDefault entityType Person
- * @paramDefault sourceEntityType Product
+ * @paramDefault sourceEntityType NetworkResource
  * @paramDefault rawIdentifier https://x.com/alice
- * @returns Promise resolving to the calculated Fide ID with format `did:fide:0x{typeChar}{sourceChar}{fingerprint}`
+ * @returns Promise resolving to the calculated Fide ID with format `did:fide:0x{typeCode}{sourceCode}{fingerprint}`
  * @throws TypeError if rawIdentifier is not a string
- * @throws Error if entityType or sourceEntityType are invalid, or if protocol constraints are violated
+ * @throws Error if entityType or sourceEntityType are invalid
+ * @remarks
+ * Intentionally non-enforcing: no canonicalization, no guessing. Callers must canonicalize
+ * raw identifiers per protocol rules before calling (e.g. URL normalization, RFC 8785 for
+ * statement payloads). Use helpers like `calculateStatementFideId` for opinionated workflows.
  */
 export declare function calculateFideId(entityType: FideEntityType, sourceEntityType: FideEntityType, rawIdentifier: string): Promise<`did:fide:0x${string}`>;

package/dist/fide-id/calculateFideId.js

@@ -1,39 +1,31 @@
 import { FIDE_ENTITY_TYPE_MAP } from "./constants.js";
+import { getSubtleCrypto } from "./utils.js";
 // Re-export for backward compatibility
 export { FIDE_ENTITY_TYPE_MAP };
-async function getSubtleCrypto() {
-    if (globalThis.crypto?.subtle) {
-        return globalThis.crypto.subtle;
-    }
-    const { webcrypto } = await import("node:crypto");
-    return webcrypto.subtle;
-}
 /**
- * Calculate a Fide ID for an entity from its type, source type, and raw identifier.
+ * Core primitive: calculate a Fide ID from type codes and raw identifier.
  *
- * Generates a unique identifier by creating a SHA-256 hash of the raw identifier,
- * then constructing a Fide ID with type and source characters followed by the last 38 hex characters.
+ * Deterministic SHA-256 hash of the raw identifier (UTF-8), then constructs
+ * `did:fide:0x` + 2 hex (type) + 2 hex (source) + first 36 hex of hash = 40 hex total.
  *
  * @param entityType The entity type.
  * @param sourceEntityType The source entity type.
- * @param rawIdentifier The raw identifier string to hash.
+ * @param rawIdentifier The raw identifier string to hash (UTF-8 encoded).
  * @paramDefault entityType Person
- * @paramDefault sourceEntityType Product
+ * @paramDefault sourceEntityType NetworkResource
  * @paramDefault rawIdentifier https://x.com/alice
- * @returns Promise resolving to the calculated Fide ID with format `did:fide:0x{typeChar}{sourceChar}{fingerprint}`
+ * @returns Promise resolving to the calculated Fide ID with format `did:fide:0x{typeCode}{sourceCode}{fingerprint}`
  * @throws TypeError if rawIdentifier is not a string
- * @throws Error if entityType or sourceEntityType are invalid, or if protocol constraints are violated
+ * @throws Error if entityType or sourceEntityType are invalid
+ * @remarks
+ * Intentionally non-enforcing: no canonicalization, no guessing. Callers must canonicalize
+ * raw identifiers per protocol rules before calling (e.g. URL normalization, RFC 8785 for
+ * statement payloads). Use helpers like `calculateStatementFideId` for opinionated workflows.
  */
 export async function calculateFideId(entityType, sourceEntityType, rawIdentifier) {
     if (typeof rawIdentifier !== "string") {
         throw new TypeError(`Invalid rawIdentifier: expected string, got ${typeof rawIdentifier}`);
     }
-    if (entityType === "Statement" && sourceEntityType !== "Statement") {
-        throw new Error(`Protocol entity ${entityType} must be self-sourced. Expected source type: ${entityType}, got: ${sourceEntityType}`);
-    }
-    if (sourceEntityType === "Statement" && entityType !== "Statement") {
-        throw new Error(`Invalid Statement source for ${entityType}: protocol disallows 0xX0 (Statement-derived) IDs for non-Statement entities. Use a concrete source (e.g. Product, Organization) instead.`);
-    }
     const entityTypeCode = FIDE_ENTITY_TYPE_MAP[entityType];
     if (!entityTypeCode) {
         throw new Error(`Invalid entityType: ${String(entityType)}`);
@@ -48,6 +40,6 @@ export async function calculateFideId(entityType, sourceEntityType, rawIdentifie
     const hashHex = Array.from(new Uint8Array(digest))
         .map((byte) => byte.toString(16).padStart(2, "0"))
         .join("");
-    const fingerprint = hashHex.slice(-38);
+    const fingerprint = hashHex.slice(0, 36);
     return `did:fide:0x${entityTypeCode}${sourceEntityTypeCode}${fingerprint}`;
 }

package/dist/fide-id/calculateStatementFideId.d.ts

@@ -1,21 +1 @@
-/**
- * Calculate a Fide ID for a Statement from its RDF triple components.
- *
- * Creates a statement Fide ID by hashing a canonical JSON representation of the subject-predicate-object triple.
- * The resulting Fide ID always has type and source both set to Statement (0x00...).
- *
- * @param subjectFideId The Fide ID reference (format: did:fide:0x... or 0x...)
- * @param predicateFideId The Fide ID reference (format: did:fide:0x... or 0x...)
- * @param objectFideId The Fide ID reference (format: did:fide:0x... or 0x...)
- * @paramDefault subjectFideId did:fide:0x152f02f1d1c1e62b2e569e11818420c1968be3d9
- * @paramDefault predicateFideId did:fide:0x6524b049fa7069dd318c44531214a955c3f1fa37
- * @paramDefault objectFideId did:fide:0x66a023246354ad7e064b1e4e009ec8a0699a3043
- * @returns Promise resolving to the calculated statement Fide ID with format `did:fide:0x00{fingerprint}`
- * @throws TypeError if any Fide ID is not a string
- * @throws Error if any Fide ID format is invalid or not in canonical form
- * @remarks
- * This function only validates Fide ID format and canonicalizes triple hashing.
- * It does not enforce statement role policy (for example allowed predicate entity/source combos).
- * Role policy checks are enforced by `createStatement`.
- */
 export declare function calculateStatementFideId(subjectFideId: string, predicateFideId: string, objectFideId: string): Promise<`did:fide:0x${string}`>;

package/dist/fide-id/calculateStatementFideId.js

@@ -1,38 +1,24 @@
-import { calculateFideId } from "./calculateFideId.js";
-function assertFideId(value) {
-    if (typeof value !== "string") {
-        throw new TypeError(`Invalid Fide ID: expected string, got ${typeof value}`);
-    }
-    if (/^did:fide:0x[0-9a-f]{40}$/.test(value)) {
-        return value;
-    }
-    throw new Error(`Invalid Fide ID format: ${value}. Expected full Fide ID (e.g., did:fide:0x...)`);
-}
 /**
  * Calculate a Fide ID for a Statement from its RDF triple components.
  *
- * Creates a statement Fide ID by hashing a canonical JSON representation of the subject-predicate-object triple.
- * The resulting Fide ID always has type and source both set to Statement (0x00...).
+ * Creates a statement Fide ID by hashing the raw identifier: concatenation of
+ * subject, predicate, and object Fide IDs in that order, separated by ASCII `|`.
+ * No whitespace. This helper always returns the self-sourced Statement form (Target/Source = `0000`).
  *
- * @param subjectFideId The Fide ID reference (format: did:fide:0x... or 0x...)
- * @param predicateFideId The Fide ID reference (format: did:fide:0x... or 0x...)
- * @param objectFideId The Fide ID reference (format: did:fide:0x... or 0x...)
- * @paramDefault subjectFideId did:fide:0x152f02f1d1c1e62b2e569e11818420c1968be3d9
- * @paramDefault predicateFideId did:fide:0x6524b049fa7069dd318c44531214a955c3f1fa37
- * @paramDefault objectFideId did:fide:0x66a023246354ad7e064b1e4e009ec8a0699a3043
- * @returns Promise resolving to the calculated statement Fide ID with format `did:fide:0x00{fingerprint}`
+ * @param subjectFideId The subject Fide ID (full format: `did:fide:0x` + 40 hex chars).
+ * @param predicateFideId The predicate Fide ID (full format: `did:fide:0x` + 40 hex chars).
+ * @param objectFideId The object Fide ID (full format: `did:fide:0x` + 40 hex chars).
+ * @returns Promise resolving to the calculated statement Fide ID with format `did:fide:0x0000{fingerprint}`
  * @throws TypeError if any Fide ID is not a string
  * @throws Error if any Fide ID format is invalid or not in canonical form
  * @remarks
  * This function only validates Fide ID format and canonicalizes triple hashing.
  * It does not enforce statement role policy (for example allowed predicate entity/source combos).
  * Role policy checks are enforced by `createStatement`.
+ * For non-self-sourced statement IDs (for example `0020`), use `calculateFideId` directly.
  */
+import { calculateFideId } from "./calculateFideId.js";
+import { statementRawIdentifier } from "./statementRawIdentifier.js";
 export async function calculateStatementFideId(subjectFideId, predicateFideId, objectFideId) {
-    const rawIdentifier = JSON.stringify({
-        o: assertFideId(objectFideId),
-        p: assertFideId(predicateFideId),
-        s: assertFideId(subjectFideId)
-    });
-    return calculateFideId("Statement", "Statement", rawIdentifier);
+    return calculateFideId("Statement", "Statement", statementRawIdentifier(subjectFideId, predicateFideId, objectFideId));
 }

package/dist/fide-id/constants.d.ts

@@ -2,20 +2,230 @@
  * FCP SDK Constants
  * Central location for all protocol constants
  */
+export declare const FCP_PROTOCOL_ID: "FCP";
+export declare const FCP_PROTOCOL_GENERATION: "1";
+export declare const FCP_SPEC_DATE: "2026-02-18";
 /**
  * Entity Type Map
- * Maps FCP entity type names to their single-character hex codes.
+ * Maps FCP entity type names to their two-character hex codes.
  * Used as both Part 1 (Entity Type) and Part 2 (Identifier Source) in Fide IDs.
+ *
+ * @pattern Multi-facet identity: A single thing often has multiple IDs. Link via Statements:
+ *   - NetworkResource ↔ (represents/delivers) ↔ CreativeWork
+ *   - PhysicalObject ↔ (embodies) ↔ CreativeWork
  */
 export declare const FIDE_ENTITY_TYPE_MAP: {
-    readonly Statement: "0";
-    readonly Person: "1";
-    readonly Organization: "2";
-    readonly AutonomousAgent: "7";
-    readonly Place: "3";
-    readonly Event: "4";
-    readonly Product: "5";
-    readonly CreativeWork: "6";
+    /**
+     * The atomic unit of the graph. An objective record of a Subject-Predicate-Object assertion.
+     *
+     * @layer Protocol
+     * @standard rdf:Statement
+     * @standardFit Exact
+     * @litmus Not a verified fact; verification is application-level. Not what it represents.
+     */
+    readonly Statement: "00";
+    /**
+     * A person (alive, dead, undead, or fictional).
+     *
+     * @layer Agents
+     * @standard schema:Person
+     * @standardFit Exact
+     * @litmus Not an account or organization.
+     */
+    readonly Person: "10";
+    /**
+     * A structured collective of people or agents that acts as a unit.
+     *
+     * @layer Agents
+     * @standard org:Organization
+     * @standardFit Exact
+     * @litmus Not a single person or software. Not a query-defined group (e.g. alumni by year); create only when the group itself needs to act.
+     */
+    readonly Organization: "11";
+    /**
+     * A running process that acts as an independent actor: bot, AI agent, smart contract. Can hold keys and sign.
+     *
+     * @layer Agents
+     * @standard schema:SoftwareApplication + prov:SoftwareAgent
+     * @standardFit Close
+     * @litmus Not a person or organization. Not static passive code (use CreativeWork for repos, images, logic).
+     */
+    readonly SoftwareAgent: "12";
+    /**
+     * Identity primarily by addressability/resolution (URL, URI, CID, etc.), regardless of authorship.
+     * Retrieved/resolved as content or endpoint. A NetworkResource often represents or delivers a CreativeWork.
+     *
+     * @layer Network Anchors
+     * @standard schema:WebPage + schema:WebSite + schema:EntryPoint
+     * @standardFit Broad
+     * @litmus Not a subset or account. Not an inhabitable spatial context (use Place).
+     */
+    readonly NetworkResource: "20";
+    /**
+     * An authority-based account principal (e.g., an email address or a specific GitHub, Google, or Mastodon user ID).
+     * The identity exists by the permission of a host system's database.
+     *
+     * @layer Network Anchors
+     * @standard schema:OnlineAccount
+     * @standardFit Close
+     * @litmus Authenticated by a host authority's database, not purely by mathematics.
+     */
+    readonly PlatformAccount: "21";
+    /**
+     * A math-based account principal (e.g., an EVM address, Bitcoin wallet, or did:key).
+     * The identity exists mathematically and is authenticated via mathematical signature keys.
+     *
+     * @layer Network Anchors
+     * @standard sec:PublicKey + sec:publicKeyMultibase
+     * @standardFit Close
+     * @litmus Authenticated via mathematical signature keys, independent of a host authority.
+     */
+    readonly CryptographicAccount: "22";
+    /**
+     * The most generic kind of creative work, including books, movies, photographs, software programs, etc.
+     * Non-expressive digital artifacts (binaries, model weights, dataset snapshots) are CreativeWork with refinement via Statements (artifactKind, mediaType, generatedBy, derivedFrom).
+     *
+     * @layer Knowledge
+     * @standard schema:CreativeWork
+     * @standardFit Exact
+     * @litmus Not a raw value or formal concept. Not a running agent instance (use SoftwareAgent). Not a resource where location is primary identifier (use NetworkResource).
+     */
+    readonly CreativeWork: "30";
+    /**
+     * A formal concept, word, topic, category, or abstract idea defined in a taxonomy.
+     *
+     * @layer Knowledge
+     * @standard schema:DefinedTerm
+     * @standardFit Close
+     * @litmus Not a plain raw value.
+     */
+    readonly Concept: "31";
+    /**
+     * A spatial context that can contain presence, co-location, and interaction. Includes physical locations and persistent virtual environments (e.g., a concert venue, a Discord server or channel, a Zoom room, a VRChat instance). Physicality/virtuality is asserted via Statements, not the base type.
+     *
+     * @layer Spacetime
+     * @standard schema:Place + schema:VirtualLocation
+     * @standardFit Broad
+     * @litmus Not a happening or a physical artifact. Can an Actor have presence there? Is its identity a spatial address rather than a document location or account?
+     */
+    readonly Place: "40";
+    /**
+     * An occurrence or happening bounded in time. Can be observed/aggregated; may be caused by Actions, systems, or nature. Occurs at a Place (physical or virtual).
+     *
+     * @layer Spacetime
+     * @standard schema:Event
+     * @standardFit Exact
+     * @litmus Not a specific exertion of agency (Action).
+     */
+    readonly Event: "41";
+    /**
+     * A discrete assertion or commitment attributable to an Agent. Often produces or records a change (e.g., a transaction, API call, signature). Can be linked to Events via Statements (causes, records, resultsIn).
+     *
+     * @layer Spacetime
+     * @standard schema:Action + prov:Activity
+     * @standardFit Close
+     * @litmus Not a broad temporal happening (Event); must be driven by an Agent.
+     */
+    readonly Action: "42";
+    /**
+     * A tangible, inanimate physical object (e.g., hardware, vehicle, physical document, natural object). Physical only. Use Statements (madeBy, manufactured=true) if man-made vs natural matters.
+     *
+     * @layer Spacetime
+     * @standard schema:Product + schema:Thing
+     * @standardFit Close
+     * @litmus Not a location (where). Not a digital artifact (use CreativeWork).
+     */
+    readonly PhysicalObject: "43";
+    /**
+     * A plain text sequence of characters.
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:string
+     * @standardFit Exact
+     * @litmus Not a Concept.
+     */
+    readonly TextLiteral: "a0";
+    /**
+     * A whole number.
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:integer
+     * @standardFit Exact
+     * @litmus Not a decimal or string.
+     */
+    readonly IntegerLiteral: "a1";
+    /**
+     * A decimal or floating-point number.
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:decimal
+     * @standardFit Exact
+     * @litmus Not an integer.
+     */
+    readonly DecimalLiteral: "a2";
+    /**
+     * A true or false value.
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:boolean
+     * @standardFit Exact
+     * @litmus Not a number or string.
+     */
+    readonly BoolLiteral: "a3";
+    /**
+     * A calendar date (YYYY-MM-DD formatted according to ISO 8601).
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:date
+     * @standardFit Exact
+     * @litmus Not a datetime or time.
+     */
+    readonly DateLiteral: "a4";
+    /**
+     * A time of day (formatted according to ISO 8601, represented in UTC).
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:time
+     * @standardFit Exact
+     * @litmus Not a date or datetime.
+     */
+    readonly TimeLiteral: "a5";
+    /**
+     * A specific point in time (ISO 8601 formatted, UTC normalized).
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:dateTime
+     * @standardFit Exact
+     * @litmus Not a date or time alone.
+     */
+    readonly DateTimeLiteral: "a6";
+    /**
+     * A calculated amount of elapsed time (ISO 8601 duration format).
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:duration
+     * @standardFit Exact
+     * @litmus Not a datetime.
+     */
+    readonly DurationLiteral: "a7";
+    /**
+     * A formalized Uniform Resource Identifier string (RFC 3986).
+     *
+     * @layer Literals
+     * @standard rdf:Literal + xsd:anyURI
+     * @standardFit Exact
+     * @litmus Not plain text.
+     */
+    readonly URILiteral: "a8";
+    /**
+     * A structured JSON object represented in canonical string form (RFC 8785).
+     *
+     * @layer Literals
+     * @standard rdf:Literal + rdf:JSON
+     * @standardFit Exact
+     * @litmus Not a string.
+     */
+    readonly JSONLiteral: "a9";
 };
 /**
  * Reverse lookup: character code to entity type name
@@ -28,7 +238,7 @@ export declare const FIDE_CHAR_TO_ENTITY_TYPE: Record<string, keyof typeof FIDE_
 export declare const FIDE_ID_PREFIX: "did:fide:0x";
 /**
  * Fide ID Length (excluding prefix)
- * 40 hex characters: 1 (type) + 1 (source) + 38 (fingerprint)
+ * 40 hex characters: 2 (type) + 2 (source) + 36 (fingerprint)
  */
 export declare const FIDE_ID_HEX_LENGTH = 40;
 /**
@@ -38,6 +248,6 @@ export declare const FIDE_ID_HEX_LENGTH = 40;
 export declare const FIDE_ID_LENGTH: number;
 /**
  * Fingerprint Length
- * Last 38 hex characters (19 bytes) of SHA-256 hash
+ * First 36 hex characters (18 bytes) of SHA-256 hash
  */
-export declare const FIDE_ID_FINGERPRINT_LENGTH = 38;
+export declare const FIDE_ID_FINGERPRINT_LENGTH = 36;