# `PtcRunner.Lisp.Java.Surface`
[🔗](https://github.com/andreasronge/ptc_runner/blob/main/lib/ptc_runner/lisp/java/surface.ex#L1)

Compile-time authority for the bounded PTC-Lisp Java compatibility surface.

The surface is data, not reflection. `priv/java_interop.exs` owns admitted
classes and references, JVM descriptors, closed dispatch routes, audit
targets, and documentation projections. Every admitted overload resolves to
a code-owned Java handler. Pinned JVM oracle fixtures independently attest
the executable descriptor inventory.

# `audit`

```elixir
@spec audit(atom()) :: [map()]
```

Returns one Java audit with stable manifest target/reference IDs removed for public compatibility.

# `audit_keys`

```elixir
@spec audit_keys() :: [atom()]
```

Returns sorted Java audit keys.

# `audit_specs`

```elixir
@spec audit_specs() :: [map()]
```

Returns Java audit specifications used by docs and upstream checks.

# `audit_targets`

```elixir
@spec audit_targets(atom()) :: [map()]
```

Returns one Java audit including stable manifest identities.

# `available_namespace_labels`

```elixir
@spec available_namespace_labels() :: [String.t()]
```

Returns Java namespace labels for analyzer diagnostics.

# `canonical_function_name`

```elixir
@spec canonical_function_name(atom() | String.t(), atom() | String.t()) ::
  String.t() | nil
```

Returns the canonical implemented-function name for one accepted namespace member.

# `class_spellings`

```elixir
@spec class_spellings() :: [String.t()]
```

Returns every admitted source spelling owned by a Java class.

# `classes`

```elixir
@spec classes() :: [map()]
```

Returns admitted and inventory-only Java class records.

# `doc_namespaces`

```elixir
@spec doc_namespaces() :: %{required(String.t()) =&gt; atom()}
```

Returns string-to-atom Java namespace mappings used by Registry documentation lookup.

# `fetch_audit_spec`

```elixir
@spec fetch_audit_spec(atom()) :: {:ok, map()} | :error
```

Fetches a Java audit specification.

# `fetch_class`

```elixir
@spec fetch_class(atom()) :: {:ok, map()} | :error
```

Fetches one admitted or inventory Java class by stable ID.

# `fetch_overload`

```elixir
@spec fetch_overload(atom()) :: {:ok, map()} | :error
```

Fetches one Java overload by stable ID.

# `fetch_reference`

```elixir
@spec fetch_reference(atom()) :: {:ok, map()} | :error
```

Fetches one Java reference by stable ID.

# `function_entries`

```elixir
@spec function_entries() :: [map()]
```

Returns Java-owned implemented-function presentation rows.

# `interop_entries`

```elixir
@spec interop_entries() :: [map()]
```

Returns generated Java interop reference presentation rows.

# `member_family?`

```elixir
@spec member_family?(atom()) :: boolean()
```

Returns true when an ID names a finite manifest-derived instance member family.

# `member_family_spelling?`

```elixir
@spec member_family_spelling?(atom() | String.t()) :: boolean()
```

Returns true when a direct-dot spelling names an admitted member family.

# `namespace?`

```elixir
@spec namespace?(atom() | String.t()) :: boolean()
```

Returns true when `namespace` is owned by the Java surface.

# `namespace_categories`

```elixir
@spec namespace_categories() :: %{required(atom()) =&gt; atom()}
```

Returns Java compatibility namespace categories for Env diagnostics.

# `namespace_members`

```elixir
@spec namespace_members(atom() | String.t()) :: [atom() | String.t()]
```

Returns the currently accepted source members of a Java namespace.

# `overloads`

```elixir
@spec overloads() :: [map()]
```

Returns admitted overload records on validated closed dispatch routes.

# `reference_label`

```elixir
@spec reference_label(atom()) :: {:ok, String.t()} | :error
```

Returns the canonical inert label for a Java reference.

# `references`

```elixir
@spec references() :: [map()]
```

Returns admitted Java reference records.

# `replace_function_entries`

```elixir
@spec replace_function_entries([map()]) :: [map()]
```

Appends manifest projections after rejecting legacy generic Java rows.

# `resolve_member_family`

```elixir
@spec resolve_member_family(atom() | String.t()) :: {:ok, atom()} | :error
```

Resolves a direct-dot source spelling to its finite instance member family.

# `resolve_plain_reference`

```elixir
@spec resolve_plain_reference(atom() | String.t()) :: {:ok, map()} | :error
```

Resolves a plain constructor source spelling to its admitted reference.

# `resolve_reference`

```elixir
@spec resolve_reference(atom() | String.t(), atom() | String.t()) ::
  {:ok, map()} | :unknown_member | :not_java_class
```

Resolves a bounded Java class/member source identity.

# `source_namespace_atoms`

```elixir
@spec source_namespace_atoms() :: [atom()]
```

Returns all Java namespace atoms admitted by the source vocabulary.

# `version`

```elixir
@spec version() :: pos_integer()
```

Returns the validated manifest version.

---

*Consult [api-reference.md](api-reference.md) for complete listing*
