relay-runtime 21.0.0 → 21.0.1

package/experimental.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { DataID } from './util/RelayRuntimeTypes';
+
+export { resolverDataInjector } from './store/live-resolvers/resolverDataInjector';
+export { observeFragment } from './store/observeFragmentExperimental';
+export { observeQuery } from './store/observeQueryExperimental';
+export { waitForFragmentData } from './store/waitForFragmentExperimental';
+
+export type IdOf<_A extends string, Typename extends undefined | string = undefined> = Typename extends undefined
+    ? { id: DataID }
+    : { id: DataID; __typename: Typename };
+
+interface ErrorResult<E> {
+    ok: false;
+    errors: readonly E[];
+}
+
+interface OkayResult<T> {
+    ok: true;
+    value: T;
+}
+
+// The type returned by fields annotated with `@catch`
+export type Result<T, E> = OkayResult<T> | ErrorResult<E>;
+
+export function isValueResult<T = unknown>(input: Result<T, unknown>): input is OkayResult<T>;
+
+export function isErrorResult<E = unknown>(input: Result<unknown, E>): input is ErrorResult<E>;

package/experimental.js

@@ -1,5 +1,5 @@
 /**
- * Relay v21.0.0
+ * Relay v21.0.1
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/experimental.js.flow

@@ -44,13 +44,13 @@ export type IdOf<A extends string, Typename extends void | string = void> = [
 export type RelayResolverValue<A> = NonNullable<A>;
 
 type ErrorResult<Error> = {
-  +ok: false,
-  +errors: ReadonlyArray<Error>,
+  readonly ok: false,
+  readonly errors: ReadonlyArray<Error>,
 };
 
 type OkayResult<T> = {
-  +ok: true,
-  +value: T,
+  readonly ok: true,
+  readonly value: T,
 };
 
 export type Result<T, Error> = OkayResult<T> | ErrorResult<Error>;

package/handlers/RelayDefaultHandlerProvider.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { Handler } from '../store/RelayStoreTypes';
+
+export type HandlerProvider = (handle: string) => Handler | undefined;
+
+export default function RelayDefaultHandlerProvider(handle: string): Handler;

package/handlers/connection/ConnectionHandler.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {
+  HandleFieldPayload,
+  ReadOnlyRecordProxy,
+  RecordProxy,
+  RecordSourceProxy,
+} from '../../store/RelayStoreTypes';
+import {DataID, Variables} from '../../util/RelayRuntimeTypes';
+
+export interface ConnectionMetadata {
+    path: readonly string[] | null | undefined;
+    direction: string | null | undefined; // 'forward' | 'backward' | 'bidirectional' | null | undefined;
+    cursor: string | null | undefined;
+    count: string | null | undefined;
+    stream?: boolean | undefined;
+}
+
+export function buildConnectionEdge(
+    store: RecordSourceProxy,
+    connection: RecordProxy,
+    edge: RecordProxy | null | undefined,
+): RecordProxy | null | undefined;
+
+export function createEdge(
+    store: RecordSourceProxy,
+    record: RecordProxy,
+    node: RecordProxy,
+    edgeType: string,
+): RecordProxy;
+
+export function deleteNode(record: RecordProxy, nodeID: DataID): void;
+
+export function getConnection(
+    record: ReadOnlyRecordProxy,
+    key: string,
+    filters?: Variables | null,
+): RecordProxy | null | undefined;
+
+export function getConnectionID(recordID: DataID, key: string, filters?: Variables | null): DataID;
+
+export function insertEdgeAfter(record: RecordProxy, newEdge: RecordProxy, cursor?: string | null): void;
+
+export function insertEdgeBefore(record: RecordProxy, newEdge: RecordProxy, cursor?: string | null): void;
+
+export function update(store: RecordSourceProxy, payload: HandleFieldPayload): void;

package/handlers/connection/ConnectionInterface.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { DataID } from '../../util/RelayRuntimeTypes';
+
+export interface EdgeRecord extends Record<string, unknown> {
+    cursor: unknown;
+    node: Record<DataID, unknown>;
+}
+
+export interface PageInfo {
+    endCursor: string | null | undefined;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor: string | null | undefined;
+}
+
+interface ConnectionConfig {
+    CURSOR: string;
+    EDGES: string;
+    END_CURSOR: string;
+    HAS_NEXT_PAGE: string;
+    HAS_PREV_PAGE: string;
+    NODE: string;
+    PAGE_INFO: string;
+    PAGE_INFO_TYPE: string;
+    START_CURSOR: string;
+}
+
+declare const ConnectionInterface: {
+    get(): ConnectionConfig;
+
+    inject(newConfig: ConnectionConfig): void;
+};
+
+export default ConnectionInterface;

package/handlers/connection/MutationHandlers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { Handler } from '../../store/RelayStoreTypes';
+
+export const MutationHandlers: {
+    DeleteRecordHandler: Handler;
+    DeleteEdgeHandler: Handler;
+    AppendEdgeHandler: Handler;
+    PrependEdgeHandler: Handler;
+    AppendNodeHandler: Handler;
+    PrependNodeHandler: Handler;
+};

package/index.d.ts

@@ -0,0 +1,274 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import * as ConnectionHandler from './handlers/connection/ConnectionHandler';
+import ConnectionInterface from './handlers/connection/ConnectionInterface';
+// Extensions
+import RelayDefaultHandlerProvider from './handlers/RelayDefaultHandlerProvider';
+import QueryResponseCache from './network/RelayQueryResponseCache';
+import * as fetchQueryInternal from './query/fetchQueryInternal';
+import * as RelayResolverFragments from './store/ResolverFragments';
+import withProvidedVariables from './util/withProvidedVariables';
+
+export { ConnectionInterface };
+export { ConnectionMetadata } from './handlers/connection/ConnectionHandler';
+export { EdgeRecord, PageInfo } from './handlers/connection/ConnectionInterface';
+export { OptimisticMutationConfig } from './mutations/applyOptimisticMutation';
+export { MutationConfig, MutationParameters } from './mutations/commitMutation';
+export {
+    DeclarativeMutationConfig,
+    MutationTypes,
+    RangeBehaviors,
+    RangeOperations,
+} from './mutations/RelayDeclarativeMutationConfig';
+export {
+    MutationTypes as MutationType,
+    RangeOperations as RangeOperation,
+} from './mutations/RelayDeclarativeMutationConfig';
+export {
+    ExecuteFunction,
+    FetchFunction,
+    GraphQLResponse,
+    GraphQLResponseWithData,
+    GraphQLResponseWithoutData,
+    GraphQLSingularResponse,
+    LogRequestInfoFunction,
+    Network as INetwork,
+    PayloadData,
+    PayloadError,
+    ReactFlightPayloadData,
+    ReactFlightPayloadQuery,
+    ReactFlightServerTree,
+    SubscribeFunction,
+    Uploadable,
+    UploadableMap,
+} from './network/RelayNetworkTypes';
+export { ObservableFromValue, Observer, Subscribable, Subscription } from './network/RelayObservable';
+export {
+    getFragment,
+    getInlineDataFragment,
+    getNode,
+    getPaginationFragment,
+    getRefetchableFragment,
+    getRequest,
+    graphql,
+    GraphQLTaggedNode,
+    isFragment,
+    isInlineDataFragment,
+    isRequest,
+} from './query/GraphQLTag';
+export { generateClientID, generateUniqueClientID, isClientID } from './store/ClientID';
+export { TaskScheduler } from './store/OperationExecutor';
+export { RecordState } from './store/RelayRecordState';
+export {
+    Environment as IEnvironment,
+    FragmentMap,
+    FragmentPointer,
+    FragmentSpecResolver,
+    FragmentType,
+    /** @deprecated use FragmentType instead of FragmentReference */
+    FragmentType as FragmentReference,
+    HandleFieldPayload,
+    HasUpdatableSpread,
+    InvalidationState,
+    LiveState,
+    LogEvent,
+    LogFunction,
+    MissingFieldHandler,
+    ModuleImportPointer,
+    MutableRecordSource,
+    NormalizationSelector,
+    OperationAvailability,
+    OperationDescriptor,
+    OperationLoader,
+    OperationTracker,
+    OptimisticResponseConfig,
+    OptimisticUpdate,
+    OptimisticUpdateFunction,
+    PluralReaderSelector,
+    Props,
+    PublishQueue,
+    ReactFlightClientResponse,
+    ReactFlightPayloadDeserializer,
+    ReaderSelector,
+    ReadOnlyRecordProxy,
+    RecordProxy,
+    RecordSourceProxy,
+    RecordSourceSelectorProxy,
+    RelayContext,
+    RelayFieldLogger,
+    RequestDescriptor,
+    SelectorData,
+    SelectorStoreUpdater,
+    SingularReaderSelector,
+    Snapshot,
+    StoreUpdater,
+    suspenseSentinel,
+    UpdatableFragmentData,
+    UpdatableQueryData,
+} from './store/RelayStoreTypes';
+export { GraphQLSubscriptionConfig } from './subscription/requestSubscription';
+export {
+    NormalizationArgument,
+    NormalizationDefer,
+    NormalizationField,
+    NormalizationFlightField,
+    NormalizationLinkedField,
+    NormalizationLinkedHandle,
+    NormalizationLocalArgumentDefinition,
+    NormalizationModuleImport,
+    NormalizationOperation,
+    NormalizationRootNode,
+    NormalizationScalarField,
+    NormalizationSelection,
+    NormalizationSplitOperation,
+    NormalizationStream,
+    NormalizationTypeDiscriminator,
+} from './util/NormalizationNode';
+export {
+    ReaderArgument,
+    ReaderArgumentDefinition,
+    ReaderCondition,
+    ReaderField,
+    ReaderFlightField,
+    ReaderFragment,
+    ReaderInlineDataFragment,
+    ReaderInlineDataFragmentSpread,
+    ReaderInlineFragment,
+    ReaderLinkedField,
+    ReaderModuleImport,
+    ReaderPaginationMetadata,
+    ReaderRefetchableFragment,
+    ReaderRefetchMetadata,
+    ReaderRequiredField,
+    ReaderScalarField,
+    ReaderSelection,
+    RequiredFieldAction,
+} from './util/ReaderNode';
+export {
+    ConcreteRequest,
+    ConcreteUpdatableQuery,
+    GeneratedNode,
+    PreloadableConcreteRequest,
+    RequestParameters,
+} from './util/RelayConcreteNode';
+export { RelayReplaySubject as ReplaySubject } from './util/RelayReplaySubject';
+export * from './util/RelayRuntimeTypes';
+// Core API
+export { RelayNetwork as Network } from './network/RelayNetwork';
+export { RelayObservable as Observable } from './network/RelayObservable';
+export { default as Environment, EnvironmentConfig } from './store/RelayModernEnvironment';
+export { QueryResponseCache };
+export { RelayModernRecord as Record } from './store/RelayModernRecord';
+export { default as Store } from './store/RelayModernStore';
+export { RelayRecordSource as RecordSource } from './store/RelayRecordSource';
+export { type IdOf, isErrorResult, isValueResult, type Result } from './experimental';
+export { createFragmentSpecResolver } from './store/createFragmentSpecResolver';
+export { readInlineData } from './store/readInlineData';
+export { createOperationDescriptor, createRequestDescriptor } from './store/RelayModernOperationDescriptor';
+export {
+    areEqualSelectors,
+    createNormalizationSelector,
+    createReaderSelector,
+    getDataIDsFromFragment,
+    getDataIDsFromObject,
+    getPluralSelector,
+    getSelector,
+    getSelectorsFromObject,
+    getSingularSelector,
+    getVariablesFromFragment,
+    getVariablesFromObject,
+    getVariablesFromPluralFragment,
+    getVariablesFromSingularFragment,
+} from './store/RelayModernSelector';
+export {
+    FRAGMENT_OWNER_KEY,
+    FRAGMENTS_KEY,
+    getModuleComponentKey,
+    getModuleOperationKey,
+    getStorageKey,
+    ID_KEY,
+    REF_KEY,
+    REFS_KEY,
+    ROOT_ID,
+    ROOT_TYPE,
+    TYPENAME_KEY,
+} from './store/RelayStoreUtils';
+export { readFragment } from './store/ResolverFragments';
+export { RelayDefaultHandlerProvider as DefaultHandlerProvider };
+export declare function getDefaultMissingFieldHandlers(): import('./store/RelayStoreTypes').MissingFieldHandler[];
+export { ConnectionHandler };
+export { MutationHandlers } from './handlers/connection/MutationHandlers';
+export { VIEWER_ID, VIEWER_TYPE } from './store/ViewerPattern';
+// Helpers (can be implemented via the above API)
+export { applyOptimisticMutation } from './mutations/applyOptimisticMutation';
+export { commitLocalUpdate } from './mutations/commitLocalUpdate';
+export { commitMutation } from './mutations/commitMutation';
+export { fetchQuery } from './query/fetchQuery';
+export { fetchQuery_DEPRECATED } from './query/fetchQuery_DEPRECATED';
+export { isRelayModernEnvironment } from './store/isRelayModernEnvironment';
+export { requestSubscription } from './subscription/requestSubscription';
+// Utilities
+export { default as createPayloadFor3DField } from './util/createPayloadFor3DField';
+export { default as getFragmentIdentifier } from './util/getFragmentIdentifier';
+export { default as getPaginationMetadata } from './util/getPaginationMetadata';
+export { default as getPaginationVariables } from './util/getPaginationVariables';
+export { Direction } from './util/getPaginationVariables';
+export { default as getRefetchMetadata } from './util/getRefetchMetadata';
+export { default as getRelayHandleKey } from './util/getRelayHandleKey';
+export { default as getRequestIdentifier } from './util/getRequestIdentifier';
+export { default as getValueAtPath } from './util/getValueAtPath';
+export { default as handlePotentialSnapshotErrors } from './util/handlePotentialSnapshotErrors';
+export declare const PreloadableQueryRegistry: {
+    set(key: string, value: import('./util/RelayConcreteNode').ConcreteRequest): void;
+    get(key: string): import('./util/RelayConcreteNode').ConcreteRequest | null | undefined;
+    onLoad(key: string, callback: (concreteRequest: import('./util/RelayConcreteNode').ConcreteRequest) => void): import('./util/RelayRuntimeTypes').Disposable;
+    clear(): void;
+};
+export { RelayProfiler } from './util/RelayProfiler';
+// INTERNAL-ONLY
+export { RelayConcreteNode } from './util/RelayConcreteNode';
+export { default as RelayError } from './util/RelayError';
+export { RelayFeatureFlags } from './util/RelayFeatureFlags';
+export const DEFAULT_HANDLE_KEY = '';
+export { default as deepFreeze } from './util/deepFreeze';
+export { default as getPendingOperationsForFragment } from './util/getPendingOperationsForFragment';
+export { default as isPromise } from './util/isPromise';
+export { default as isScalarAndEqual } from './util/isScalarAndEqual';
+export { default as recycleNodesInto } from './util/recycleNodesInto';
+export { default as stableCopy } from './util/stableCopy';
+
+interface Internal {
+    fetchQuery: typeof fetchQueryInternal.fetchQuery;
+    fetchQueryDeduped: typeof fetchQueryInternal.fetchQueryDeduped;
+    getPromiseForActiveRequest: typeof fetchQueryInternal.getPromiseForActiveRequest;
+    getObservableForActiveRequest: typeof fetchQueryInternal.getObservableForActiveRequest;
+    ResolverFragments: typeof RelayResolverFragments;
+    withProvidedVariables: typeof withProvidedVariables;
+}
+
+export const __internal: Internal;
+
+/**
+ * relay-compiler-language-typescript support for fragment references
+ */
+
+export interface _RefType<Ref extends string> {
+    ' $fragmentType': Ref;
+}
+
+export interface _FragmentRefs<Refs extends string> {
+    ' $fragmentSpreads': FragmentRefs<Refs>;
+}
+
+// This is used in the actual artifacts to define the various fragment references a container holds.
+export type FragmentRefs<Refs extends string> = {
+    [ref in Refs]: true;
+};
+
+// This is a utility type for converting from a data type to a fragment reference that will resolve to that data type.
+export type FragmentRef<Fragment> = Fragment extends _RefType<infer U> ? _FragmentRefs<U> : never;

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v21.0.0
+ * Relay v21.0.1
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/llm-docs/api-reference/relay-runtime/fetch-query.mdx

@@ -48,6 +48,11 @@ fetchQuery(
 * `options`: *_[Optional]_* options object
     * `networkCacheConfig`: *_[Optional]_ *Object containing cache config options
         * `force`: Boolean value. If true, will bypass the network response cache. Defaults to true.
+    * `fetchPolicy`: *_[Optional]_* Determines whether `fetchQuery` should reuse data that is already available in the local Relay store. Must be one of the following values:
+        * `"network-only"`: *(default)* Always issue a network request, regardless of what is in the store.
+        * `"store-or-network"`: Reuse data from the store if the full query is available locally; otherwise, issue a network request.
+
+        The `"store-and-network"` and `"store-only"` fetch policies are **not supported** by `fetchQuery`, because it is designed around issuing a single network request and returning the response.
 
 ### Flow Type Parameters
 

package/llm-docs/getting-started/compiler.mdx

@@ -62,7 +62,22 @@ npm run relay
 If you have [watchman](https://facebook.github.io/watchman) installed you can pass `--watch` to the Relay compiler to have it continue running and automatically update generated files as you edit your product code:
 
 ```sh
-npm run relay --watch
+relay-compiler --watch
+```
+
+### Validate mode
+
+Pass `--validate` to check whether any generated artifacts are out of date without writing anything to disk. The compiler exits with a non-zero code if any artifacts need to be updated. This is useful in CI to assert that generated files are committed and current:
+
+```sh
+relay-compiler --validate
+```
+### Disabling watchman
+
+By default, Relay uses [watchman](https://facebook.github.io/watchman), if installed, for fast file discovery. To fall back to directory traversal instead, pass `--no-watchman`:
+
+```sh
+relay-compiler --no-watchman
 ```
 
 ### Codemods
@@ -75,8 +90,9 @@ The Relay compiler can compare two GraphQL documents to determine if one is a su
 
 ### Help
 
-To learn about the other capabilities of the Relay compiler see its extensive `--help` output:
+To see the full command-line reference run:
 
 ```sh
-npm run relay --help
+relay-compiler --help
+relay-compiler <subcommand> --help
 ```

package/llm-docs/getting-started/quick-start.mdx

@@ -32,7 +32,7 @@ cd relay-example
 # Runtime dependencies
 npm install relay-runtime react-relay
 # Dev dependencies
-npm install --save-dev babel-plugin-relay graphql relay-compiler
+npm install --save-dev babel-plugin-relay graphql relay-compiler @rolldown/plugin-babel
 ```
 
 :::tip
@@ -45,19 +45,19 @@ npx skills install facebook/relay
 
 ## Configure Vite to use Relay
 
-Relay uses a [Babel plugin](./babel-plugin.mdx) to insert code generated by the Relay compiler into your bundle. We can enable the Relay Babel plugin we installed earlier by configuring the React Vite plugin.
+Relay uses a [Babel plugin](./babel-plugin.mdx) to insert code generated by the Relay compiler into your bundle. We can enable the Relay Babel plugin we installed earlier by configuring the Babel Vite plugin.
 
 ```tsx title="vite.config.ts"
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+// change-line
+import babel from "@rolldown/plugin-babel";
 
 // https://vite.dev/config/
 export default defineConfig({
-  plugins: [
-    // change-line
-    react({ babel: { plugins: ["relay"] } })
-  ],
-})
+  // change-line
+  plugins: [react(), babel({ plugins: ["relay"] })],
+});
 ```
 
 See [Babel Plugin](./babel-plugin.mdx) for information about how to configure the Babel plugin for other build systems.
@@ -87,12 +87,14 @@ See [Relay Compiler](./compiler.mdx) for more information about configuring and
 To allow components within our application to fetch GraphQL we configure a Relay Environment to fetch from our test endpoint and add it to React context.
 
 ```tsx title="src/main.tsx"
+import type { FetchFunction } from "relay-runtime";
+
 import { StrictMode, Suspense } from "react";
 import { createRoot } from "react-dom/client";
 import "./index.css";
 import App from "./App.tsx";
 import { RelayEnvironmentProvider } from "react-relay";
-import { Environment, Network, FetchFunction } from "relay-runtime";
+import { Environment, Network } from "relay-runtime";
 
 const HTTP_ENDPOINT = "https://graphql.org/graphql/";
 
@@ -134,9 +136,10 @@ See [Relay Environment](../api-reference/relay-runtime/relay-environment.mdx) fo
 Finally we can start defining the data we want to fetch and build our UI. Our app will fetch a list of films and render each one using a `<Film>` component.
 
 ```tsx title="src/App.tsx"
-import { AppQuery } from "./__generated__/AppQuery.graphql";
+import type { AppQuery } from "./__generated__/AppQuery.graphql";
+
 import { graphql, useLazyLoadQuery } from "react-relay";
-import Film from "./Film";
+import Film from "./Film.tsx";
 
 export default function App() {
   const data = useLazyLoadQuery<AppQuery>(

package/llm-docs/guides/codemods.mdx

@@ -24,6 +24,8 @@ Usage: relay codemod [OPTIONS] [CONFIG] <COMMAND>
 
 Commands:
   mark-dangerous-conditional-fragment-spreads  Marks unaliased conditional fragment spreads as @dangerously_unaliased_fixme
+  remove-unnecessary-required-directives       Removes @required directives from non-null fields within @throwOnFieldError fragments and operations.
+  fix-all                                      Runs all Relay compiler transforms and fixes all fixable diagnostics
   help                                         Print this message or the help of the given subcommand(s)
 
 Arguments:
@@ -52,7 +54,7 @@ can be enabled, which will ensure any future ambiguous fragment spreads must be
 aliased.
 
 Since this codemod can potentially modify many files, there is an optional
-`--rollout` parameter which, if used alongside the
+`--rollout-percentage` parameter (shorthand: `-r`) which, if used alongside the
 `enforce_fragment_alias_where_ambiguous` feature flag in rollout mode, allows
 progressive codemod and enforcement of this validation.
 
@@ -64,3 +66,14 @@ directives from non-null fields within
 fragments and operations, or linked fields with
 [`@catch`](../guides/catch-directive.mdx), where the compiler is certain that the
 directive does not change the generated types for the data being fetched.
+
+### fix-all
+
+Runs all Relay compiler transforms and automatically applies fixes for every
+fixable diagnostic. This is a convenient catch-all codemod to apply when
+upgrading Relay versions — run it after updating the package to repair any
+issues the compiler now flags:
+
+```sh
+relay codemod fix-all
+```

package/multi-actor-environment/ActorIdentifier.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * A unique identifier of the current actor.
+ */
+export type ActorIdentifier = string;
+
+export function assertInternalActorIdentifier(actorIdentifier: ActorIdentifier): void;
+
+export function getActorIdentifier(actorID: string): ActorIdentifier;
+
+export function getDefaultActorIdentifier(): ActorIdentifier;

package/multi-actor-environment/ActorSpecificEnvironment.js.flow

@@ -61,15 +61,15 @@ export type ActorSpecificEnvironmentConfig = Readonly<{
 
 class ActorSpecificEnvironment implements IActorEnvironment {
   __log: LogFunction;
-  +_defaultRenderPolicy: RenderPolicy;
-  +_network: INetwork;
-  +_operationTracker: OperationTracker;
-  +_publishQueue: RelayPublishQueue;
-  +_store: Store;
-  +actorIdentifier: ActorIdentifier;
-  +configName: ?string;
-  +multiActorEnvironment: IMultiActorEnvironment;
-  +options: unknown;
+  readonly _defaultRenderPolicy: RenderPolicy;
+  readonly _network: INetwork;
+  readonly _operationTracker: OperationTracker;
+  readonly _publishQueue: RelayPublishQueue;
+  readonly _store: Store;
+  readonly actorIdentifier: ActorIdentifier;
+  readonly configName: ?string;
+  readonly multiActorEnvironment: IMultiActorEnvironment;
+  readonly options: unknown;
   relayFieldLogger: RelayFieldLogger;
 
   constructor(config: ActorSpecificEnvironmentConfig) {