# Custom semantics

One owns the universal `.one` envelope and standard semantic distribution. It
does not own every meaning expressed through them.

## Publish a peer domain

An organization can publish a `SemanticDomainPackage` in its own namespace.
The package defines a closed declaration vocabulary, product/variant schemas,
invariants, defaults, compatibility rules, dependencies, normalization, and
conformance.

```one
one 1
domain acme.compliance#Compliance@1
namespace acme.policies

# declarations governed by Acme, not redefined as one.* meaning
```

The package uses the same owner-neutral Contracts meta-contract as a One-owned
domain. It does not require a parser plugin, core grammar edit, central kind
registry, or translation to `one.*`.

## Build an end-to-end ecosystem

A domain owner can publish independently useful, atom-sized packages for:

- schemas and normalization;
- requirements and planning contributions;
- implementation claims and conformance;
- source-language or projection profiles;
- providers, build, deployment, and evidence.

Every later-stage proposal enters through that stage owner's bounded public
validation contract. A domain package never receives unrestricted access to
another system's internal IR.

## Compose without stealing ownership

Semantic dependencies make identities referenceable and impose obligations.
They do not transfer meaning, select an implementation, or grant authority.

When two owners need interoperability, an explicit directional mapping names:

- exact source and destination identities;
- complete obligation and loss dispositions;
- destination-owner validation;
- the root in which the mapping is selected.

No mapping is needed when meanings remain independent.

## Extend languages separately

An organization may also own a `SourceLanguageDefinition` or
`ImplementationLanguageProfile`. That makes its implementation language
available to exact tooling and Build without adding tokens or semantics to
System IDL or native One.

Custom semantics and custom implementation languages therefore compose through
contracts rather than compiler plugins.

Canonical owners:
[Contracts](https://github.com/muijf/one/blob/main/systems/contracts/AGENTS.md),
[Composition](https://github.com/muijf/one/blob/main/systems/composition/AGENTS.md),
and
[Providers](https://github.com/muijf/one/blob/main/systems/providers/AGENTS.md).