@@ -69,6 +69,17 @@ shared namespace ([ADR-0003](docs/adr/0003-the-shared-namespace-decides-key-clas
 and the grammar of the `/etc/hosts` compose2pod writes
 ([ADR-0006](docs/adr/0006-docker-rejection-parity.md)).
 
+**Name grammar / volume discriminator**:
+Two different questions Docker answers with two different rules, once conflated
+here into one pattern. The *name grammar* (`values.TOP_LEVEL_NAME`,
+`[a-zA-Z0-9._-]+`) is what a top-level `services`/`volumes`/`secrets`/`configs`
+key and a service's long-form `networks` key must match. The *discriminator*
+(`parsing._is_named_volume_source`) asks a different thing of a short-form
+volume source — named volume, or bind? — and does not use the grammar at all:
+a leading `.`, `/` or `~` is a host path, anything else is a volume name. Say
+which one you mean; one pattern doing both jobs is the bug
+[ADR-0006](docs/adr/0006-docker-rejection-parity.md) records.
+
 **Store**:
 The umbrella noun for a Compose `secret` or `config` — the two `StoreKind`s in
 `stores.py`. Use *store* for anything true of both, which is nearly everything.
 
@@ -130,19 +130,45 @@ def _validate_service_healthcheck(name: str, svc: dict[str, Any]) -> None:
             _HEALTHCHECK_SCALAR_VALIDATORS[key](name, key, healthcheck[key])
 
 
+# A short-form volume source Docker reads as a host path rather than a volume
+# name. Measured over 19 spellings against `docker compose config` v5.1.2.
+_BIND_SOURCE_PREFIXES = (".", "/", "~")
+
+
+def _is_named_volume_source(source: str) -> bool:
+    r"""Whether a SHORT-form volume source names a volume, as Docker reads it.
+
+    A leading `.`, `/` or `~` makes it a host path; every other spelling is a
+    volume name, `a/b`, `a b` and `a@b` included -- each measured as
+    `refers to undefined volume` with no top-level declaration. The name
+    grammar does not decide this and must not be asked to: it would call
+    those three binds, which is exactly how they stayed accepted until issue
+    143 measured them. An earlier split used this same leading-character rule
+    without `~` and swept `~/data` into "named" wrongly; `~` was the missing
+    prefix, not the grammar.
+
+    A `${VAR}`-carrying source stays unnamed on purpose: what it resolves to
+    is a fact about the shell that will run the script, not about the
+    document, the carve-out `_validate_volume_references` documents.
+
+    No drive-shaped entry (`C:\\data:/var`, `v:/data`) reaches this:
+    `_validate_service_volumes` refuses the family first, so a `named` verdict
+    here always names a volume Docker would name too.
+    """
+    return not source.startswith(_BIND_SOURCE_PREFIXES) and not values.has_variable(source)
+
+
 def _classify_volume(volume: str) -> tuple[str, str | None]:
     r"""Classify one short-syntax volume entry: its kind, and its source when the kind is 'named'.
 
     Returns `("anonymous", None)` for a colon-less entry (a bare container
-    path), `("named", source)` for a colon-form entry whose source matches
-    Docker's own volume-name grammar (`stores.NAME_PATTERN`, the identical
-    pattern a secret/config name is checked against:
-    `^[a-zA-Z0-9][a-zA-Z0-9_.-]*$`), or `("bind", None)` for every other
-    colon-form entry -- a relative (`./rel`) or absolute (`/abs`) host path, a
-    `~`-prefixed home-relative path (`~/data`, measured ACCEPT against
-    `docker compose config` v5.1.2 with no top-level declaration -- Docker
-    expands it against the invoking user's home directory), or a `${VAR}`
-    reference (`$`, `{`, `}` are none of them pattern characters either).
+    path), `("named", source)` per `_is_named_volume_source` above, or
+    `("bind", None)` for every other colon-form entry -- a relative (`./rel`)
+    or absolute (`/abs`) host path, a `~`-prefixed home-relative path
+    (`~/data`, measured ACCEPT against `docker compose config` v5.1.2 with no
+    top-level declaration -- Docker expands it against the invoking user's
+    home directory), or a `${VAR}` reference (`$`, `{`, `}` are none of them
+    name-grammar characters either).
 
     Shared by `_validate_service_volumes` (only cares whether an entry is
     anonymous, to check its own shape) and `_named_volume_source` (only cares
@@ -162,7 +188,7 @@ def _classify_volume(volume: str) -> tuple[str, str | None]:
     if ":" not in volume:
         return "anonymous", None
     source, _, _ = volume.partition(":")
-    if stores.NAME_PATTERN.fullmatch(source):
+    if _is_named_volume_source(source):
         return "named", source
     return "bind", None
 
@@ -427,14 +453,17 @@ def _named_volume_source(volume: object) -> str | None:
     """Return a volume entry's bare-identifier named source, or None if it needs no declaration.
 
     A colon-form short-syntax string is classified via `_classify_volume`. A
-    long-syntax mapping needs its own check: only a `volume`-type entry names
-    a volume at all, and only when its `source` is a bare identifier (an
+    long-syntax mapping needs its own check, and a laxer one: `type` has
+    already said which kind the entry is, so a `volume`-type entry names a
+    volume whatever its `source` looks like -- `source: /abs` and
+    `source: ./r` are both `refers to undefined volume` to Docker, where the
+    short form reads the same strings as host paths (measured, v5.1.2). An
     absent source is an anonymous volume; a `bind`/`tmpfs` entry's `source`,
-    if any, is a host path, never a name to cross-check).
+    if any, is a host path, never a name to cross-check.
     """
     if isinstance(volume, dict):
         source = volume.get("source")
-        if volume.get("type") == "volume" and isinstance(source, str) and stores.NAME_PATTERN.fullmatch(source):
+        if volume.get("type") == "volume" and isinstance(source, str) and not values.has_variable(source):
             return source
         return None
     # _validate_service_volumes has already confirmed every non-dict entry is
@@ -1105,9 +1134,8 @@ def _validate_volume_references(compose: dict[str, Any], services: dict[str, Any
     undeclared when it resolves to a bare identifier, a fact about the shell
     that will later run the generated script, not about this document, so it
     does not bind here either way. `_named_volume_source` already returns None
-    for any `${...}`-carrying source unconditionally -- `$`, `{`, and `}` are
-    none of them `stores.NAME_PATTERN` characters -- so this function never
-    needs to ask `values.has_variable` itself.
+    for any `${...}`-carrying source, in both syntaxes and by an explicit
+    `values.has_variable` test, so this function never needs to ask again.
     """
     top_volumes = compose.get("volumes")
     if top_volumes is not None and not isinstance(top_volumes, dict):
@@ -1175,6 +1203,7 @@ def _validate_network_entry_value(name: str, network: str, value: Any) -> None:
     can never satisfy "must be a mapping" regardless of its runtime value --
     the rejection is a fact about the document, not the host.
     """
+    values.validate_compose_name(f"service {name!r}: network name", network)
     if value is None:
         return
     if not isinstance(value, dict):
@@ -1558,6 +1587,25 @@ def _validate_top_level_scalar_strings(compose: dict[str, Any]) -> None:
             raise UnsupportedComposeError(msg)
 
 
+# The top-level blocks whose KEYS Docker holds to its name grammar. `networks`
+# is absent by measurement, not oversight: `networks: {"a b": {}}` on its own
+# is accepted by `docker compose config` v5.1.2, and the grammar bites on the
+# service's long-form `networks` mapping key instead (`_validate_network_entries`).
+NAME_CHECKED_TOP_LEVEL_BLOCKS = ("services", "volumes", "secrets", "configs")
+
+
+def _validate_top_level_names(compose: dict[str, Any]) -> None:
+    """Every key of every name-checked top-level block, against Docker's one grammar.
+
+    A block that is not a mapping is left to the validator that owns its shape.
+    """
+    for block in NAME_CHECKED_TOP_LEVEL_BLOCKS:
+        definitions = compose.get(block)
+        if isinstance(definitions, dict):
+            for name in definitions:
+                values.validate_compose_name(f"top-level {block!r}: name", name)
+
+
 def validate(compose: dict[str, Any]) -> list[str]:
     """Check the compose document against the supported subset.
 
@@ -1579,6 +1627,7 @@ def validate(compose: dict[str, Any]) -> list[str]:
         raise UnsupportedComposeError(msg)
     _reject_null_top_level_blocks(compose)
     _validate_top_level_scalar_strings(compose)
+    _validate_top_level_names(compose)
     if "networks" in compose:
         warnings.append("ignoring top-level 'networks' (all services share the pod namespace)")
     if "volumes" in compose:
 
@@ -19,13 +19,6 @@
 
 
 _LONG_FORM_KEYS = {"source", "target", "uid", "gid", "mode"}
-# Docker's shared identifier grammar for a secret/config *name* -- and, per
-# `parsing._named_volume_source`, for telling a named-volume reference apart
-# from a bind-mount source (a relative or absolute path, or a `~`-prefixed
-# home-relative path all fail this pattern, since none of `.`, `/`, `~` is a
-# pattern character). Public (no leading underscore) because parsing.py, in a
-# different module, reuses it rather than duplicating it.
-NAME_PATTERN = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_.-]*$")
 _ENV_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
 
 
@@ -67,9 +60,6 @@ class StoreKind:
 
 
 def _validate_def(name: str, definition: Any, kind: StoreKind) -> None:  # noqa: ANN401 - Compose values are untyped
-    if not NAME_PATTERN.fullmatch(name):
-        msg = f"{kind.label} name {name!r} must match [a-zA-Z0-9][a-zA-Z0-9_.-]*"
-        raise UnsupportedComposeError(msg)
     if not isinstance(definition, dict):
         msg = f"{kind.label} {name!r} must be a mapping"
         raise UnsupportedComposeError(msg)
@@ -209,6 +199,10 @@ def _create(definition: dict[str, Any], store: str, project_dir: str) -> CreateS
     Whichever source the store declares, the expandable text is bound once and
     both outputs are read off that binding, so a line cannot expand a variable
     the caller is never told about.
+
+    `store` is interpolated unquoted, which is safe because the gate holds
+    every top-level key to `values.NAME_GRAMMAR` -- a check that lives in
+    `parsing`, not here, since issue 143 made it one grammar for five blocks.
     """
     if isinstance(definition.get("file"), str):
         value = str(Path(project_dir, definition["file"]))
 
@@ -309,6 +309,32 @@ def validate_duration(name: str, key: str, value: Any) -> None:  # noqa: ANN401
     raise UnsupportedComposeError(msg)
 
 
+NAME_GRAMMAR = re.compile(r"^[a-zA-Z0-9._-]+\Z")
+
+
+def validate_compose_name(where: str, name: str) -> None:
+    """Refuse an identifier Docker's schema will not take in the position `where` names.
+
+    One grammar, `[a-zA-Z0-9._-]+`, measured against `docker compose config`
+    v5.1.2 and pinned by `tests/conformance/test_matrix.py`. A leading `.`,
+    `-` or `_` is legal, which is where the old store-only pattern was
+    stricter than Docker. `where` is pre-formatted by the caller, as
+    `keys.require_string_keys` takes one, because the positions this is
+    enforced from share no argument shape.
+
+    Where Docker enforces it is not where it reads most naturally: the keys of
+    top-level `services`, `volumes`, `secrets` and `configs`, and a service's
+    long-form `networks` mapping key, but NOT a top-level `networks:` key --
+    `networks: {"a b": {}}` alone is a document Docker accepts.
+
+    This is rule one, not a narrowing: a document carrying one of these is a
+    document `docker compose config` rejects outright.
+    """
+    if not NAME_GRAMMAR.fullmatch(name):
+        msg = f"{where} {name!r} must match [a-zA-Z0-9._-]+"
+        raise UnsupportedComposeError(msg)
+
+
 _UNSPELLABLE_IN_HOSTS_FILE = frozenset(" \t\n\r\v\f#")
 
 
 
@@ -79,7 +79,27 @@ named volume) ([#114](https://github.com/modern-python/compose2pod/issues/114)),
 `mode` is refused at the other end of the range, where podman 6.0.1's `crun` will not mount it.
 The `integration` job pins `ubuntu-24.04` for the same reason: it is the runner that ships the
 floor, and on a newer one the job would measure a podman no user of the floor has.
-The hard rule has no exceptions left. It had two, and both were the same one: a `depends_on`
+The hard rule has no exceptions left. It had three classes, and the third outlived the sentence
+that first said this. Docker's identifier grammar, `[a-zA-Z0-9._-]+`, was never modelled: a
+service, volume, secret or config could be named `a b`, `a/b` or `""`, all of which
+`docker compose config` refuses outright and all of which compose2pod took
+([#143](https://github.com/modern-python/compose2pod/issues/143)). One pattern in `values`
+holds it now, applied where Docker applies it -- which is not where it reads: the keys of
+top-level `services`, `volumes`, `secrets` and `configs`, and a service's *long-form* `networks`
+mapping key, but neither a top-level `networks:` key nor a short-form list entry, each measured
+rather than assumed and each pinned. The same pattern had a second job it was quietly bad at:
+`stores.NAME_PATTERN` demanded an alphanumeric first character Docker does not, over-rejecting
+`.a`, `-a` and `_a`, while doubling as the short-form bind-versus-named-volume test, which is not
+a grammar question at all: Docker reads a leading `.`, `/` or `~` as a host path and every other
+spelling as a volume name, `a/b` and `a b` included. One pattern could not be both -- widening it
+would have read `.env:/app/.env` as a named volume, and leaving it would have kept `a/b:/x`
+accepted where Docker says `refers to undefined volume`. They are two rules now, and the long
+form is a third: there `type` has already said which kind the entry is, so any source names a
+volume.
+Why the harness never saw it: the generated matrix varies a key's *value* over hostile shapes and
+never touches a map key, so no probe could reach a name. `test_identifier_grammar_matches_docker`
+now generates the missing axis from the same tuple the gate reads.
+The first two exceptions were the same one: a `depends_on`
 naming an undefined service, and a dependency cycle, among services outside the target's closure
 were rejected by Docker and accepted here
 ([#87](https://github.com/modern-python/compose2pod/issues/87)), because both checks lived in the
 
@@ -0,0 +1,11 @@
+# Measured ACCEPT by `docker compose config` v5.1.2: a top-level `networks:` key is NOT
+# held to the identifier grammar the other blocks' keys are, and neither is a service's
+# short-form (list) reference to one. Only the long-form mapping key is. Pinned so the
+# grammar cannot be tidied into applying everywhere, which would over-reject (issue 143).
+services:
+  app:
+    image: nginx
+    networks:
+      - "a b"
+networks:
+  "a b": {}
@@ -253,3 +253,16 @@ def test_extra_hosts_address_newline_is_a_catalogued_over_rejection(
     """
     path = Path(__file__).parent / "corpus" / "service_extra_hosts_address_newline.yaml"
     assert assert_rule(yaml.safe_load(path.read_text())) == "over-reject"
+
+
+def test_top_level_network_name_is_accepted_by_both(
+    assert_rule: Callable[[dict[str, Any]], str],
+) -> None:
+    """Docker's identifier grammar does not reach a top-level `networks:` key.
+
+    Pinned to `both-accept` rather than left to the generic run, which tolerates an
+    over-rejection: the risk here is the opposite of the usual one, that the grammar
+    issue 143 added gets extended to a position Docker leaves alone.
+    """
+    path = Path(__file__).parent / "corpus" / "networks_top_level_name_unchecked.yaml"
+    assert assert_rule(yaml.safe_load(path.read_text())) == "both-accept"
@@ -11,7 +11,7 @@
 import pytest
 
 from compose2pod.keys import SERVICE_KEYS, STRUCTURAL_KEYS
-from compose2pod.parsing import IGNORED_SERVICE_KEYS
+from compose2pod.parsing import IGNORED_SERVICE_KEYS, NAME_CHECKED_TOP_LEVEL_BLOCKS
 
 
 KEYS = sorted(set(SERVICE_KEYS) | STRUCTURAL_KEYS | set(IGNORED_SERVICE_KEYS))
@@ -84,3 +84,56 @@ def test_docker_rejection_implies_our_rejection(
         pytest.skip("host-dependent shape -- see CARVE_OUT's comment")
     compose = {"services": {"app": {"image": "nginx:alpine", key: SHAPES[shape]}}}
     assert_rule(compose)
+
+
+REFUSED_NAMES = ["a b", "a/b", "a:b", "a#b", "ab!", "a+b", "a~b", "a@b", "a$b", "", "\xe4"]
+# The four Docker takes that the old store-only pattern refused -- the over-rejection
+# issue 143 lifted. They carry `both-accept` below, so lifting it cannot silently undo.
+ACCEPTED_NAMES = [".a", "-a", "_a", "a.b"]
+# The full set on the two positions the grammar is enforced from, a hostile pair on the
+# remaining blocks: Docker applies one grammar to all of them (measured), and the pair is
+# what would catch a block that stopped sharing it.
+CROSS_BLOCK_NAMES = ("a b", "")
+_OTHER_BLOCKS = [block for block in NAME_CHECKED_TOP_LEVEL_BLOCKS if block != "services"]
+NAME_POSITIONS = (
+    [("services", name, "both-reject") for name in REFUSED_NAMES]
+    + [("services", name, "both-accept") for name in ACCEPTED_NAMES]
+    + [("service-networks", name, "both-reject") for name in REFUSED_NAMES]
+    + [("service-networks", name, "both-accept") for name in ACCEPTED_NAMES]
+    + [(block, name, "both-reject") for block in _OTHER_BLOCKS for name in CROSS_BLOCK_NAMES]
+)
+
+
+def _document_named(position: str, name: str) -> dict[str, Any]:
+    """Build a document whose only variable is one identifier, in the position under probe."""
+    app: dict[str, Any] = {"image": "nginx:alpine"}
+    compose: dict[str, Any] = {"services": {"app": app}}
+    if position == "services":
+        compose["services"][name] = {"image": "nginx:alpine"}
+    elif position == "service-networks":
+        app["networks"] = {name: {}}
+        compose["networks"] = {name: {}}
+    elif position in ("secrets", "configs"):
+        compose[position] = {name: {"file": "./f"}}
+    else:
+        compose[position] = {name: {}}
+    return compose
+
+
+@pytest.mark.parametrize(("position", "name", "verdict"), NAME_POSITIONS, ids=lambda value: repr(value).strip("'"))
+def test_identifier_grammar_matches_docker(
+    position: str,
+    name: str,
+    verdict: str,
+    assert_rule: Callable[[dict[str, Any]], str],
+) -> None:
+    """Both directions, per position: what Docker refuses we refuse, what it takes we take.
+
+    The verdict is asserted rather than left to `assert_rule` alone, which tolerates an
+    over-rejection -- and an over-rejection on `ACCEPTED_NAMES` is precisely the defect
+    issue 143 removed, so the generic contract cannot see the thing under test.
+
+    Generated from `NAME_CHECKED_TOP_LEVEL_BLOCKS` so a block added to that tuple is
+    probed the moment it is added, the way a new `SERVICE_KEYS` entry is above.
+    """
+    assert assert_rule(_document_named(position, name)) == verdict