Profiles Overview

Each ZineCore2 profile is published as five synchronized artifacts following what we call the "Five Pillars" pattern. This approach ensures that the same metadata specification is available in formats suitable for different audiences and use cases.

The Four Profiles

The Five Pillars

Every profile is published in five formats, each serving a different purpose:

Pillar 1: DCAP Narrative (Markdown)

Purpose: Human-readable specification document Audience: Everyone — developers, librarians, metadata specialists Format: Markdown (.md)

What it contains:

• Introduction and scope
• Alignment with standards (Dublin Core, BIBFRAME, Schema.org)
• Detailed element descriptions
• Usage notes and examples
• Privacy and ethical considerations

When to use: Understanding the specification, creating documentation, crosswalking to other standards

Pillar 2: DC TAP Table (CSV)

Purpose: Tabular Application Profile for metadata mapping Audience: Librarians, metadata specialists, crosswalk creators Format: CSV (Comma-Separated Values) Location: ZineCore2 | AgentCore2 | HoldingCore2 | RepoCore2

What it contains:

When to use: Mapping to MARC, MODS, EAD, or other metadata standards; documenting element decisions

Example:

propertyID,propertyLabel,mandatory,repeatable,note
dcterms:title,Title,TRUE,FALSE,Primary title of the zine
dcterms:creator,Creator,TRUE,TRUE,Use AgentCore2 agent_id values
zine:seriesTitle,Series Title,FALSE,FALSE,Name of series if part of one

Download ZineCore2 TAP →

Pillar 3: JSON Schema (JSON)

Purpose: Validation and type checking for JSON records Audience: Developers, API implementers Format: JSON Schema (Draft 2020-12) Location: ZineCore2 | AgentCore2 | HoldingCore2 | RepoCore2

What it contains:

• Property definitions with types
• Required vs. optional fields
• Array constraints (minItems, uniqueItems)
• String patterns and formats
• Enum constraints for controlled vocabularies

When to use: Validating JSON records with AJV, jsonschema (Python), or other validators; generating documentation; IDE autocomplete

Example:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "title": {
      "type": "string",
      "description": "Primary title of the zine"
    },
    "creator": {
      "type": "array",
      "items": { "type": "string" },
      "minItems": 1,
      "description": "Agent IDs from AgentCore2"
    }
  },
  "required": ["title", "creator", "subject", "genre"]
}

Download ZineCore2 Schema →

Pillar 4: JSON-LD Context (JSON-LD)

Purpose: Semantic web integration and RDF expansion Audience: Linked data developers, semantic web applications Format: JSON-LD Context Location: ZineCore2 | AgentCore2 | HoldingCore2 | RepoCore2

What it contains:

• Mappings from short field names to full URIs
• Type coercions (@type: @id for references)
• Language tags
• Namespace prefixes

When to use: Expanding JSON to RDF triples; integrating with triple stores; SPARQL queries; publishing as linked data

Example:

{
  "@context": {
    "@vocab": "https://zinecore.org/v2/zine#",
    "dc": "http://purl.org/dc/terms/",
    "title": "dc:title",
    "creator": {
      "@id": "dc:creator",
      "@type": "@id"
    },
    "date": {
      "@id": "dc:date",
      "@type": "http://www.w3.org/2001/XMLSchema#gYear"
    }
  }
}

Download ZineCore2 Context →

Pillar 5: TypeScript Types (.d.ts)

Purpose: Type safety for JavaScript/TypeScript development Audience: TypeScript developers Format: TypeScript Declaration Files Location: ZineCore2 | AgentCore2 | HoldingCore2 | RepoCore2

What it contains:

• Interface definitions for each profile
• Optional vs. required properties
• Array types
• String literal unions for controlled vocabularies

When to use: Building TypeScript applications; IDE autocomplete; compile-time type checking

Example:

export interface ZineCore2 {
  id?: string;
  title: string;
  creator: string[];  // AgentCore2 IDs
  subject: string[];  // From subjects vocabulary
  genre: string[];    // From genres vocabulary
  date: string;       // ISO 8601 year or date
  language: string[]; // ISO 639 codes
  rights: string;     // From rights vocabulary
  series_title?: string;
  issue_designation?: string;
  // ... more fields
}

Download ZineCore2 Types →

How to Read Profile Pages

Each profile page on this website includes:

1. Overview

Context about what the profile describes and why it exists.

2. Standards Alignment

How the profile maps to Dublin Core, BIBFRAME, and Schema.org.

3. Complete Schema Table

A comprehensive table showing all metadata elements:

Column guide:

• ID — Field name in JSON (snake_case)
• Label — Human-readable name
• DC Mapping — Dublin Core property URI
• Required — Must be present? (Yes/No)
• Repeatable — Can have multiple values? (Yes/No)
• Notes — Usage guidance, vocabulary constraints

4. Cardinality Notation

We use this notation for field requirements:

5. Controlled Vocabulary Constraints

Fields using controlled vocabularies show the constraint:

Example: subject (0..n) — Values from subjects vocabulary

This means:

• 0 or more subject terms can be provided
• Values must come from the canonical subjects vocabulary
• Use the code field from vocabulary terms (e.g., "feminism", "reproductive-rights")

6. Example JSON Record

Each profile page includes a complete, realistic example:

{
  "id": "zine_mutate_3_1st",
  "title": "Mutate Zine #3: Abortion Stories",
  "creator": ["agent_judith_arcana"],
  "subject": ["feminism", "reproductive-rights", "personal-narratives"],
  "genre": ["personal-zine"],
  "date": "2024",
  "language": ["en"],
  "rights": "cc-by-4.0"
}

Profile Relationships

Profiles connect through identifier references:

ZineCore2.creator → AgentCore2.id
HoldingCore2.zine_id → ZineCore2.id
HoldingCore2.repository_id → RepoCore2.id

This enables:

1. Normalization — Store agent information once, reference many times
2. Referential integrity — Validate that referenced IDs exist
3. Query traversal — "Show me all zines by this creator"
4. Data federation — Different organizations can maintain different profiles

Field Naming Conventions

Validation Workflow

Here's how to validate a record against a profile:

1. Write your JSON following the profile structure
2. Validate with JSON Schema using AJV or similar:

import Ajv from 'ajv';
const ajv = new Ajv();

const schema = await fetch('/specs/schemas/zinecore2.schema.json')
  .then(r => r.json());

const validate = ajv.compile(schema);
const valid = validate(myZineRecord);

if (!valid) {
  console.error(validate.errors);
}

3. Check vocabulary constraints — Ensure subject/genre/rights values exist in vocabularies
4. Verify references — Ensure creator IDs exist in AgentCore2 records
5. Test JSON-LD expansion (optional) — Use the playground

Next Steps

• ZineCore2 Profile — Complete bibliographic specification
• AgentCore2 Profile — Creator/contributor authority records
• HoldingCore2 Profile — Physical/digital copy holdings
• RepoCore2 Profile — Repository descriptions
• Schema Validator — Test your JSON records