bookwright-cli 0.3.1__tar.gz → 0.3.2__tar.gz

{bookwright_cli-0.3.1 → bookwright_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bookwright-cli
-Version: 0.3.1
+Version: 0.3.2
 Summary: Spec-driven authoring toolkit for novels, essays, and memoirs.
 Project-URL: Homepage, https://github.com/jmorenobl/bookwright
 Project-URL: Repository, https://github.com/jmorenobl/bookwright

{bookwright_cli-0.3.1 → bookwright_cli-0.3.2}/src/bookwright/__init__.py

@@ -1,3 +1,3 @@
 """Bookwright — Spec-driven authoring toolkit."""
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"

{bookwright_cli-0.3.1 → bookwright_cli-0.3.2}/src/bookwright/golem/deferrals.py

@@ -1,6 +1,6 @@
 """The deferral registry: which GOLEM concepts are modelled but not yet fed.
 
-Seven of the thirteen :data:`bookwright.golem.CONCEPTS` have no authored-text
+Six of the thirteen :data:`bookwright.golem.CONCEPTS` have no authored-text
 ingestion path today — they are *modelled* (a frozen class, a ``CLASS_IRI``
 entry) but never *materialized* by any builder over ``bible/*.md``. This module
 names them explicitly so the gap is a written contract rather than silent.
@@ -34,10 +34,6 @@ class DeferralNote(NamedTuple):
 
 
 DEFERRED_CONCEPTS: dict[str, DeferralNote] = {
-    "NarrativeLocation": DeferralNote(
-        reason="scaffold/skill write bible/locations/ but nothing ingests it (G13)",
-        target_version="v0.3.x",
-    ),
     "Object": DeferralNote(
         reason="no builder, no bible/objects/, no skill (G16)",
         target_version="v0.3.x",
@@ -63,5 +59,5 @@ DEFERRED_CONCEPTS: dict[str, DeferralNote] = {
         target_version="undecided",
     ),
 }
-"""Concept name → deferral note. Exactly seven entries, each key a ``CONCEPTS``
+"""Concept name → deferral note. Exactly six entries, each key a ``CONCEPTS``
 member; the orphan set the parity test derives must equal this dict's keys."""

bookwright_cli-0.3.2/src/bookwright/io/_bible_builders.py

@@ -0,0 +1,268 @@
+"""Concrete builders, coercers, and the mapper's context/result records.
+
+A behavior-preserving extraction from :mod:`bookwright.io.bible` (iteration 025):
+``bible.py`` keeps the orchestration — discovering files and wiring per-concept
+passes — while this module holds the leaf builders that turn one frontmatter
+mapping into a GOLEM entity, the value coercers they share, and the mutable
+context / immutable result records threaded through the whole map.
+
+The dependency is **one-way**: ``bible.py`` imports these names; this module
+imports nothing from ``bible.py`` (no cycle — Principle IX). It depends only on
+``golem``, ``io.errors``, ``io.report``, and the stdlib.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from rdflib.term import URIRef
+
+from bookwright.golem import Character, EmptySlugError, NarrativeEvent, NarrativeLocation
+from bookwright.golem.base import GolemEntity
+from bookwright.golem.namespaces import TEMPORAL_RELATIONS
+from bookwright.golem.slug import make_slug
+
+from .errors import InvalidFrontmatterError, SlugCollisionError
+from .report import SkippedFile, UnknownKey, UnresolvedParticipant
+
+# The five qualitative temporal relations an event may declare (each a list of
+# event names resolved against the timeline's own event index — research D11).
+# Derived from the single source of truth so the keys never drift from the model;
+# ``bible.py`` imports it to assemble ``EVENT_ITEM_KEYS``.
+RELATION_KEYS: tuple[str, ...] = tuple(rel.name for rel in TEMPORAL_RELATIONS)
+
+# A directory builder maps ``(frontmatter, relpath) → entity``; a collection
+# builder maps an ``_ItemContext`` (name, resolved participants, the raw item, and
+# the collection's own name→URI index) → entity. Typed so ``mypy --strict`` checks
+# every call site (rather than the previous ``Any`` escape hatch).
+_Builder = Callable[[dict[str, Any], str], GolemEntity]
+_ItemBuilder = Callable[["_ItemContext"], GolemEntity]
+
+
+@dataclass(frozen=True)
+class MappedEntity:
+    """One constructed entity paired with the source needed for provenance (R6)."""
+
+    entity: GolemEntity
+    relpath: str
+    key_lines: dict[str, int]
+
+
+@dataclass
+class MapResult:
+    """The outcome of mapping a project's bible to GOLEM entities."""
+
+    mapped: list[MappedEntity] = field(default_factory=list)
+    files_processed: int = 0
+    skipped: list[SkippedFile] = field(default_factory=list)
+    unknown_keys: list[UnknownKey] = field(default_factory=list)
+    unresolved_participants: list[UnresolvedParticipant] = field(default_factory=list)
+    # ``make_slug(name) → URI`` for every character, setting, event and location — the
+    # research ``bears_on``/``constrains`` targets (D11), distinct from participant
+    # ``slug_index``.
+    entity_index: dict[str, URIRef] = field(default_factory=dict)
+
+    @property
+    def entities(self) -> list[GolemEntity]:
+        return [m.entity for m in self.mapped]
+
+
+class _Collisions:
+    """Tracks ``(concept, slug) → relpath`` to detect identifier collisions (FR-014)."""
+
+    def __init__(self) -> None:
+        self._seen: dict[tuple[str, str], str] = {}
+
+    def record(self, concept: str, slug: str, relpath: str) -> None:
+        prior = self._seen.get((concept, slug))
+        if prior is not None and prior != relpath:
+            raise SlugCollisionError(slug, prior, relpath)
+        self._seen[(concept, slug)] = relpath
+
+
+@dataclass
+class _MapContext:
+    """The mutable state every mapping helper shares (R3).
+
+    Bundling ``project_root``, the accumulating ``result``, the collision
+    tracker, and the resolution indices into one object keeps each helper's
+    signature small — the four used to be threaded positionally through every
+    function. ``settings_index`` is the settings-scoped name→URI index a
+    location's ``setting:`` resolves against (iteration 025), kept separate from
+    the character-scoped ``slug_index`` and the research ``entity_index``.
+    """
+
+    project_root: Path
+    result: MapResult
+    collisions: _Collisions
+    slug_index: dict[str, URIRef]
+    settings_index: dict[str, URIRef] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class _ItemContext:
+    """Everything a collection builder needs for one item (R3)."""
+
+    ctx: _MapContext
+    item: dict[str, Any]
+    name: str
+    participants: tuple[URIRef, ...]
+    relpath: str
+    item_index: dict[str, URIRef]
+
+
+def _require_name(metadata: dict[str, Any]) -> str:
+    name = metadata.get("name")
+    if not isinstance(name, str) or not name.strip():
+        raise InvalidFrontmatterError("", "missing or empty `name`")
+    return name
+
+
+def _coerce_year(value: Any, field_name: str) -> int | None:
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise InvalidFrontmatterError("", f"`{field_name}` must be an integer year")
+    return value
+
+
+def _coerce_str_list(value: Any, field_name: str) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+        raise InvalidFrontmatterError("", f"`{field_name}` must be a list of strings")
+    return tuple(value)
+
+
+def _build_character(uri_base: str, metadata: dict[str, Any]) -> Character:
+    name = _require_name(metadata)
+    born = _coerce_year(metadata.get("born"), "born")
+    died = _coerce_year(metadata.get("died"), "died")
+    features = _coerce_str_list(metadata.get("features"), "features")
+    roles = _coerce_str_list(metadata.get("narrative_roles"), "narrative_roles")
+    return Character(
+        uri_base=uri_base,
+        name=name,
+        born=born,
+        died=died,
+        features=features,
+        narrative_roles=roles,
+    )
+
+
+def _build_event(uri_base: str, ic: _ItemContext) -> NarrativeEvent:
+    """Construct a ``NarrativeEvent`` from a timeline item: interval + relations."""
+    begin, end = _resolve_interval(ic)
+    relations = {
+        key: _resolve_refs(ic.ctx, ic.item.get(key), ic.item_index, ic.name, ic.relpath)
+        for key in RELATION_KEYS
+    }
+    return NarrativeEvent(
+        uri_base=uri_base,
+        name=ic.name,
+        participants=ic.participants,
+        begin=begin,
+        end=end,
+        **relations,
+    )
+
+
+def _resolve_interval(ic: _ItemContext) -> tuple[int | None, int | None]:
+    """Coerce ``begin`` / ``end`` / ``date`` to int years, enforcing exclusivity.
+
+    ``date`` is a single-year shorthand (``begin == end``). Supplying ``date``
+    alongside ``begin``/``end`` is a soft warning (``date`` ignored), like an
+    unknown key — never an abort.
+    """
+    begin = _coerce_year(ic.item.get("begin"), "begin")
+    end = _coerce_year(ic.item.get("end"), "end")
+    date = _coerce_year(ic.item.get("date"), "date")
+    if date is not None:
+        if begin is not None or end is not None:
+            # Mutually exclusive: keep begin/end, drop date, flag it softly.
+            ic.ctx.result.unknown_keys.append(UnknownKey(path=ic.relpath, key="date"))
+        else:
+            return date, date
+    return begin, end
+
+
+def _resolve_refs(
+    ctx: _MapContext,
+    raw: Any,
+    index: dict[str, URIRef],
+    entity_name: str,
+    relpath: str,
+) -> tuple[URIRef, ...]:
+    """Resolve a list of names against ``index`` (characters or sibling events).
+
+    A non-list value, or a name absent from the index, is surfaced as an
+    ``UnresolvedParticipant`` soft warning (no abort); the owning entity is built.
+    """
+    if raw is None:
+        return ()
+    if not isinstance(raw, list):
+        ctx.result.unresolved_participants.append(
+            UnresolvedParticipant(path=relpath, entity=entity_name, name=str(raw))
+        )
+        return ()
+    resolved: list[URIRef] = []
+    for ref in raw:
+        if not isinstance(ref, str):
+            continue
+        uri = index.get(make_slug(ref))
+        if uri is None:
+            ctx.result.unresolved_participants.append(
+                UnresolvedParticipant(path=relpath, entity=entity_name, name=ref)
+            )
+            continue
+        resolved.append(uri)
+    return tuple(resolved)
+
+
+def _resolve_setting(
+    ctx: _MapContext, metadata: dict[str, Any], entity_name: str, relpath: str
+) -> URIRef | None:
+    """Resolve an optional ``setting:`` against the settings-scoped index (FR-003/004).
+
+    Absent / ``None`` / blank-or-whitespace → no edge. A non-string is unusable
+    frontmatter (``InvalidFrontmatterError`` → the file is skipped). A present name
+    that resolves yields the setting's URI (the ``dlp:generic-location`` target); a
+    present name that does not resolve — including one that slugs to nothing — is a
+    soft miss recorded as an ``UnresolvedParticipant`` (the location is still built,
+    no edge, no abort).
+    """
+    value = metadata.get("setting")
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise InvalidFrontmatterError("", "`setting` must be a string")
+    if not value.strip():
+        return None
+    try:
+        slug = make_slug(value)
+    except EmptySlugError:
+        slug = None
+    uri = ctx.settings_index.get(slug) if slug is not None else None
+    if uri is None:
+        ctx.result.unresolved_participants.append(
+            UnresolvedParticipant(path=relpath, entity=entity_name, name=value)
+        )
+        return None
+    return uri
+
+
+def _build_location(
+    uri_base: str, ctx: _MapContext, metadata: dict[str, Any], relpath: str
+) -> NarrativeLocation:
+    """Build a ``NarrativeLocation`` (G13) from ``name`` + optional ``setting`` (FR-001/002)."""
+    name = _require_name(metadata)
+    # Validate the name slugs *before* resolving ``setting:``, so an unsluggable name
+    # aborts (→ the file is skipped) without ``_resolve_setting`` first recording a
+    # stray unresolved-participant warning for a file that produces no entity. Keeps
+    # the invariant that a skipped file appears only under ``skipped``.
+    make_slug(name)
+    setting = _resolve_setting(ctx, metadata, name, relpath)
+    return NarrativeLocation(uri_base=uri_base, name=name, setting=setting)

{bookwright_cli-0.3.1 → bookwright_cli-0.3.2}/src/bookwright/io/bible.py

@@ -5,12 +5,19 @@ frontmatter values straight to the iteration-5 constructors — it never builds
 feature/role/dimension nodes itself (data-model § 0/§ 3). It collects soft
 warnings (``unknown_keys``, ``unresolved_participants``), skips files whose
 frontmatter is unusable (FR-013), and raises on a slug collision (FR-014).
+
+This module owns the orchestration: discovering files, wiring the per-concept
+passes, and emitting provenance. The leaf builders, coercers, and the
+context/result records live in the sibling :mod:`._bible_builders` (a one-way
+dependency — this module imports from it, never the reverse). The public surface
+(``map_bible``, ``build_provenance``, ``MapResult``, ``MappedEntity``) is
+re-exported here so existing imports keep resolving.
 """
 
 from __future__ import annotations
 
 from collections.abc import Callable, Iterable
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
@@ -19,100 +26,79 @@ from rdflib.term import URIRef
 
 from bookwright.golem import (
     AttributeAssignment,
-    Character,
     EmptySlugError,
-    NarrativeEvent,
     Setting,
     SocialRelationship,
 )
 from bookwright.golem.base import GolemEntity
-from bookwright.golem.namespaces import TEMPORAL_RELATIONS
 from bookwright.golem.slug import make_slug
 
-from .errors import InvalidFrontmatterError, SlugCollisionError
+from ._bible_builders import (
+    RELATION_KEYS,
+    MappedEntity,
+    MapResult,
+    _build_character,
+    _build_event,
+    _build_location,
+    _Builder,
+    _coerce_str_list,
+    _coerce_year,
+    _Collisions,
+    _ItemBuilder,
+    _ItemContext,
+    _MapContext,
+    _require_name,
+    _resolve_interval,
+    _resolve_refs,
+    _resolve_setting,
+)
+from .errors import InvalidFrontmatterError
 from .frontmatter import Frontmatter, parse_frontmatter
-from .report import SkippedFile, UnknownKey, UnresolvedParticipant
+from .report import SkippedFile, UnknownKey
+
+__all__ = [
+    "CHARACTER_KEYS",
+    "EVENT_ITEM_KEYS",
+    "ITEM_KEYS",
+    "LOCATION_KEYS",
+    "RELATIONSHIPS_TOP_KEYS",
+    "RELATION_KEYS",
+    "SETTING_KEYS",
+    "TIMELINE_TOP_KEYS",
+    "MapResult",
+    "MappedEntity",
+    "_Collisions",
+    "_ItemContext",
+    # Re-exported from ._bible_builders so ``from bookwright.io.bible import …`` keeps working.
+    "_MapContext",
+    "_build_character",
+    "_build_event",
+    "_build_location",
+    "_coerce_str_list",
+    "_coerce_year",
+    "_require_name",
+    "_resolve_interval",
+    "_resolve_refs",
+    "_resolve_setting",
+    "build_provenance",
+    "map_bible",
+]
 
 CHARACTER_KEYS = frozenset({"name", "born", "died", "features", "narrative_roles"})
 SETTING_KEYS = frozenset({"name"})
+LOCATION_KEYS = frozenset({"name", "setting"})
 ITEM_KEYS = frozenset({"name", "participants"})
-# The five qualitative temporal relations an event may declare (each a list of
-# event names resolved against the timeline's own event index — research D11).
-# Derived from the single source of truth so the keys never drift from the model.
-RELATION_KEYS: tuple[str, ...] = tuple(rel.name for rel in TEMPORAL_RELATIONS)
 # Events additionally accept an interval (``begin`` / ``end`` years, or the
-# ``date`` single-year shorthand) plus the relation keys.
+# ``date`` single-year shorthand) plus the relation keys (defined in
+# ``._bible_builders`` alongside ``_build_event``).
 EVENT_ITEM_KEYS = frozenset({"name", "participants", "begin", "end", "date", *RELATION_KEYS})
 TIMELINE_TOP_KEYS = frozenset({"events"})
 RELATIONSHIPS_TOP_KEYS = frozenset({"relationships"})
 
-# A directory builder maps ``(frontmatter, relpath) → entity``; a collection
-# builder maps an ``_ItemContext`` (name, resolved participants, the raw item, and
-# the collection's own name→URI index) → entity. Typed so ``mypy --strict`` checks
-# every call site (rather than the previous ``Any`` escape hatch).
-_Builder = Callable[[dict[str, Any], str], GolemEntity]
-_ItemBuilder = Callable[["_ItemContext"], GolemEntity]
-
-
-@dataclass(frozen=True)
-class MappedEntity:
-    """One constructed entity paired with the source needed for provenance (R6)."""
-
-    entity: GolemEntity
-    relpath: str
-    key_lines: dict[str, int]
-
-
-@dataclass
-class MapResult:
-    """The outcome of mapping a project's bible to GOLEM entities."""
-
-    mapped: list[MappedEntity] = field(default_factory=list)
-    files_processed: int = 0
-    skipped: list[SkippedFile] = field(default_factory=list)
-    unknown_keys: list[UnknownKey] = field(default_factory=list)
-    unresolved_participants: list[UnresolvedParticipant] = field(default_factory=list)
-    # ``make_slug(name) → URI`` for every character, setting and event — the research
-    # ``bears_on``/``constrains`` targets (D11), distinct from participant ``slug_index``.
-    entity_index: dict[str, URIRef] = field(default_factory=dict)
-
-    @property
-    def entities(self) -> list[GolemEntity]:
-        return [m.entity for m in self.mapped]
-
-
-class _Collisions:
-    """Tracks ``(concept, slug) → relpath`` to detect identifier collisions (FR-014)."""
-
-    def __init__(self) -> None:
-        self._seen: dict[tuple[str, str], str] = {}
-
-    def record(self, concept: str, slug: str, relpath: str) -> None:
-        prior = self._seen.get((concept, slug))
-        if prior is not None and prior != relpath:
-            raise SlugCollisionError(slug, prior, relpath)
-        self._seen[(concept, slug)] = relpath
-
-
-@dataclass
-class _MapContext:
-    """The mutable state every mapping helper shares (R3).
-
-    Bundling ``project_root``, the accumulating ``result``, the collision
-    tracker, and the ``slug → URI`` index into one object keeps each helper's
-    signature small — the four used to be threaded positionally through every
-    function.
-    """
-
-    project_root: Path
-    result: MapResult
-    collisions: _Collisions
-    slug_index: dict[str, URIRef]
-
 
 @dataclass(frozen=True)
 class _DirSpec:
-    """Per-concept config for a one-entity-per-file directory (characters/settings)."""
+    """Per-concept config for a one-entity-per-file directory (characters/settings/locations)."""
 
     directory: Path
     concept: str
@@ -122,6 +108,9 @@ class _DirSpec:
     # Whether built entities feed the research ``entity_index`` (D11) — separate from
     # ``index`` so a setting joins it without changing participant resolution.
     into_entity_index: bool = False
+    # Whether built entities feed the settings-scoped ``settings_index`` a location's
+    # ``setting:`` resolves against (iteration 025) — only the settings pass sets it.
+    into_settings_index: bool = False
 
 
 @dataclass(frozen=True)
@@ -142,25 +131,14 @@ class _CollectionSpec:
     into_entity_index: bool = False
 
 
-@dataclass(frozen=True)
-class _ItemContext:
-    """Everything a collection builder needs for one item (R3)."""
-
-    ctx: _MapContext
-    item: dict[str, Any]
-    name: str
-    participants: tuple[URIRef, ...]
-    relpath: str
-    item_index: dict[str, URIRef]
-
-
 def map_bible(project_root: Path, bible_dir: Path, uri_base: str) -> MapResult:
     """Map every recognised bible file under ``bible_dir`` to GOLEM entities.
 
-    Characters and settings are one-entity-per-file; ``timeline.md`` /
+    Characters, settings and locations are one-entity-per-file; ``timeline.md`` /
     ``relationships.md`` are single collection files. Characters are constructed
     first so ``events:`` / ``relationships:`` participants resolve against a
-    ``slug → URI`` index in a single pass.
+    ``slug → URI`` index in a single pass; settings are mapped **before** locations
+    so a location's ``setting:`` resolves against the settings-scoped index.
     """
     ctx = _MapContext(
         project_root=project_root,
@@ -189,6 +167,18 @@ def map_bible(project_root: Path, bible_dir: Path, uri_base: str) -> MapResult:
             allowed_keys=SETTING_KEYS,
             index=False,
             into_entity_index=True,
+            into_settings_index=True,
+        ),
+    )
+    _map_single_dir(
+        ctx,
+        _DirSpec(
+            directory=bible_dir / "locations",
+            concept="NarrativeLocation",
+            builder=lambda meta, rp: _build_location(uri_base, ctx, meta, rp),
+            allowed_keys=LOCATION_KEYS,
+            index=False,
+            into_entity_index=True,
         ),
     )
     _map_collection(
@@ -244,13 +234,6 @@ def _relpath(path: Path, project_root: Path) -> str:
     return path.relative_to(project_root).as_posix()
 
 
-def _require_name(metadata: dict[str, Any]) -> str:
-    name = metadata.get("name")
-    if not isinstance(name, str) or not name.strip():
-        raise InvalidFrontmatterError("", "missing or empty `name`")
-    return name
-
-
 def _record_unknown_keys(
     ctx: _MapContext, metadata: dict[str, Any], allowed: frozenset[str], relpath: str
 ) -> None:
@@ -259,38 +242,6 @@ def _record_unknown_keys(
             ctx.result.unknown_keys.append(UnknownKey(path=relpath, key=key))
 
 
-def _build_character(uri_base: str, metadata: dict[str, Any]) -> Character:
-    name = _require_name(metadata)
-    born = _coerce_year(metadata.get("born"), "born")
-    died = _coerce_year(metadata.get("died"), "died")
-    features = _coerce_str_list(metadata.get("features"), "features")
-    roles = _coerce_str_list(metadata.get("narrative_roles"), "narrative_roles")
-    return Character(
-        uri_base=uri_base,
-        name=name,
-        born=born,
-        died=died,
-        features=features,
-        narrative_roles=roles,
-    )
-
-
-def _coerce_year(value: Any, field_name: str) -> int | None:
-    if value is None:
-        return None
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise InvalidFrontmatterError("", f"`{field_name}` must be an integer year")
-    return value
-
-
-def _coerce_str_list(value: Any, field_name: str) -> tuple[str, ...]:
-    if value is None:
-        return ()
-    if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
-        raise InvalidFrontmatterError("", f"`{field_name}` must be a list of strings")
-    return tuple(value)
-
-
 def _map_single_dir(ctx: _MapContext, spec: _DirSpec) -> None:
     if not spec.directory.is_dir():
         return
@@ -317,6 +268,8 @@ def _map_single_dir(ctx: _MapContext, spec: _DirSpec) -> None:
             ctx.slug_index[_slug_of(entity)] = entity.uri
         if spec.into_entity_index:
             ctx.result.entity_index[_slug_of(entity)] = entity.uri
+        if spec.into_settings_index:
+            ctx.settings_index[_slug_of(entity)] = entity.uri
         ctx.result.mapped.append(
             MappedEntity(entity=entity, relpath=relpath, key_lines=frontmatter.key_lines)
         )
@@ -409,75 +362,6 @@ def _map_collection_item(
     )
 
 
-def _build_event(uri_base: str, ic: _ItemContext) -> NarrativeEvent:
-    """Construct a ``NarrativeEvent`` from a timeline item: interval + relations."""
-    begin, end = _resolve_interval(ic)
-    relations = {
-        key: _resolve_refs(ic.ctx, ic.item.get(key), ic.item_index, ic.name, ic.relpath)
-        for key in RELATION_KEYS
-    }
-    return NarrativeEvent(
-        uri_base=uri_base,
-        name=ic.name,
-        participants=ic.participants,
-        begin=begin,
-        end=end,
-        **relations,
-    )
-
-
-def _resolve_interval(ic: _ItemContext) -> tuple[int | None, int | None]:
-    """Coerce ``begin`` / ``end`` / ``date`` to int years, enforcing exclusivity.
-
-    ``date`` is a single-year shorthand (``begin == end``). Supplying ``date``
-    alongside ``begin``/``end`` is a soft warning (``date`` ignored), like an
-    unknown key — never an abort.
-    """
-    begin = _coerce_year(ic.item.get("begin"), "begin")
-    end = _coerce_year(ic.item.get("end"), "end")
-    date = _coerce_year(ic.item.get("date"), "date")
-    if date is not None:
-        if begin is not None or end is not None:
-            # Mutually exclusive: keep begin/end, drop date, flag it softly.
-            ic.ctx.result.unknown_keys.append(UnknownKey(path=ic.relpath, key="date"))
-        else:
-            return date, date
-    return begin, end
-
-
-def _resolve_refs(
-    ctx: _MapContext,
-    raw: Any,
-    index: dict[str, URIRef],
-    entity_name: str,
-    relpath: str,
-) -> tuple[URIRef, ...]:
-    """Resolve a list of names against ``index`` (characters or sibling events).
-
-    A non-list value, or a name absent from the index, is surfaced as an
-    ``UnresolvedParticipant`` soft warning (no abort); the owning entity is built.
-    """
-    if raw is None:
-        return ()
-    if not isinstance(raw, list):
-        ctx.result.unresolved_participants.append(
-            UnresolvedParticipant(path=relpath, entity=entity_name, name=str(raw))
-        )
-        return ()
-    resolved: list[URIRef] = []
-    for ref in raw:
-        if not isinstance(ref, str):
-            continue
-        uri = index.get(make_slug(ref))
-        if uri is None:
-            ctx.result.unresolved_participants.append(
-                UnresolvedParticipant(path=relpath, entity=entity_name, name=ref)
-            )
-            continue
-        resolved.append(uri)
-    return tuple(resolved)
-
-
 def _safe_parse(ctx: _MapContext, path: Path, relpath: str) -> Frontmatter | None:
     try:
         text = path.read_text(encoding="utf-8")

{bookwright_cli-0.3.1 → bookwright_cli-0.3.2}/src/bookwright/resources/commands/bookwright-bible.md

@@ -39,10 +39,11 @@ constitución y el brief; trabajas sobre el proyecto inicializado.
    `bible/settings/<slug>.md`: frontmatter con **solo** la clave `name` (cadena
    obligatoria) y secciones en prosa *Cultura*, *Sistema / era* y *Geografía
    amplia* — es el universo narrativo amplio (región, era, cultura), no un lugar
-   concreto. Por cada lugar concreto, crea `bible/locations/<slug>.md`: **no se
-   indexa en v0**, así que va sin frontmatter ingerido; ánclalo en los cinco
-   sentidos con secciones *Qué se ve / oye / huele / toca* y *Atmósfera
-   dominante*.
+   concreto. Por cada lugar concreto, crea `bible/locations/<slug>.md`: frontmatter
+   con `name:` (cadena obligatoria; el *slug* deriva de él) y `setting:` opcional —
+   el `name` de un `bible/settings/` hermano, que enlaza la localización a su
+   universo vía `dlp:generic-location`. Ánclalo además en los cinco sentidos con
+   secciones en prosa *Qué se ve / oye / huele / toca* y *Atmósfera dominante*.
 5. Puebla los contenedores indexados respetando su contrato de clave única:
    `bible/timeline.md` (clave `events:`, ver
    `references/golem-events-timeline.md`) y `bible/relationships.md` (clave